max_acc:\\n max_acc = test_acc\\n model.save(join(home, save_path, model_name))\\n print(\\\"accuracy: \\\", test_acc, \\\"\\\\n Loss:\\\", test_loss)\",\n \"def trainer(current_gpu, args):\\n\\n model_history = train_utils.init_model_history()\\n batch_size = args.batch_size\\n num_epochs = args.num_epochs\\n feature_extract = False\\n\\n model = train_utils.initialize_ft_model(args.model_name, num_classes=args.num_classes, feature_extract=feature_extract)\\n model, args = dist_setting(current_gpu, model, args)\\n logger.info(f\\\"==> Training on rank {args.rank}.\\\")\\n logger.info(args)\\n \\n dataloaders, transforms, train_sampler = train_utils.create_dataloaders(\\n args.train_dir, args.valid_dir, rank=args.rank, \\n world_size=args.world_size, batch_size=batch_size,\\n num_workers=args.num_workers\\n )\\n \\n optimizer = train_utils.initialize_optimizer(model, feature_extract, lr=args.lr*args.world_size, momentum=0.9) \\n criterion = nn.CrossEntropyLoss()\\n\\n since = time.time()\\n val_acc_history = []\\n best_model_wts = copy.deepcopy(model.state_dict())\\n best_acc1 = 0.0\\n num_samples = {k: len(dataloaders[k].dataset) for k, v in dataloaders.items()}\\n num_steps = {k: int(np.ceil(len(dataloaders[k].dataset) / (batch_size*args.world_size))) for k, v in dataloaders.items()}\\n device = torch.device(f'cuda:{current_gpu}') \\n\\n for epoch in range(1, num_epochs+1):\\n \\n batch_time = train_utils.AverageMeter('Time', ':6.3f')\\n data_time = train_utils.AverageMeter('Data', ':6.3f')\\n losses = train_utils.AverageMeter('Loss', ':.4e')\\n top1 = train_utils.AverageMeter('Acc@1', ':6.2f')\\n \\n logger.info('-' * 40)\\n logger.info('[Rank {}, Epoch {}/{}] Processing...'.format(args.rank, epoch, num_epochs))\\n logger.info('-' * 40)\\n\\n # Each epoch has a training and validation phase\\n for phase in ['train', 'valid']: \\n\\n if phase == 'train':\\n model.train() # Set model to training mode\\n if args.multigpus_distributed:\\n dataloaders[phase].sampler.set_epoch(epoch) # Set epoch count for DistributedSampler \\n else:\\n model.eval() # Set model to evaluate mode\\n\\n running_loss = 0.0\\n running_corrects = 0\\n epoch_tic = time.time() \\n tic = time.time()\\n \\n for i, (inputs, labels) in enumerate(dataloaders[phase]):\\n # measure data loading time\\n data_time.update(time.time() - tic) \\n \\n inputs = inputs.to(device)\\n labels = labels.to(device)\\n\\n optimizer.zero_grad()\\n\\n with torch.set_grad_enabled(phase=='train'):\\n outputs = model(inputs)\\n loss = criterion(outputs, labels)\\n probs, preds = torch.max(outputs, 1)\\n \\n # Compute gradient and do stochastic gradient descent\\n if phase == 'train':\\n loss.backward()\\n optimizer.step()\\n \\n running_loss += loss.item() * inputs.size(0)\\n running_corrects += torch.sum(preds == labels.data)\\n acc1 = train_utils.accuracy(outputs, labels, topk=(1,))\\n \\n # Average loss and accuracy across processes for logging\\n if args.multigpus_distributed:\\n reduced_loss = train_utils.reduce_tensor(loss.data, args)\\n reduced_acc1 = train_utils.reduce_tensor(acc1[0], args)\\n else:\\n reduced_loss = loss.data\\n reduced_acc1 = acc1[0]\\n\\n losses.update(train_utils.to_python_float(reduced_loss), inputs.size(0))\\n top1.update(train_utils.to_python_float(reduced_acc1), inputs.size(0))\\n \\n # measure elapsed time\\n batch_time.update(time.time() - tic)\\n tic = time.time()\\n\\n if phase == 'train' and i % args.log_interval == 0:\\n step_loss = running_loss / ((i+1)*batch_size)\\n step_acc = running_corrects.double() / ((i+1)*batch_size)\\n logger.info(f'[Rank {args.rank}, Epoch {epoch}/{num_epochs}, Step {i+1}/{num_steps[phase]}] {phase}-acc: {step_acc:.4f}, '\\n f'{phase}-loss: {step_loss:.4f}, data-time: {data_time.val:.4f}, batch-time: {batch_time.val:.4f}') \\n \\n\\n ## Waiting until finishing operations on GPU (Pytorch default: async)\\n torch.cuda.synchronize()\\n \\n if current_gpu == 0: \\n logger.info(f'[Epoch {epoch}/{num_epochs}] {phase}-acc: {top1.avg:.4f}, '\\n f'{phase}-loss: {losses.val:.4f}, time: {time.time()-epoch_tic:.4f}') \\n \\n model_history['epoch'].append(epoch)\\n model_history['batch_idx'].append(i)\\n model_history['data_time'].append(data_time.val) \\n model_history['batch_time'].append(batch_time.val)\\n model_history['losses'].append(losses.val)\\n model_history['top1'].append(top1.val)\\n\\n if phase == 'valid':\\n is_best = top1.avg > best_acc1\\n best_acc1 = max(top1.avg, best_acc1)\\n \\n if (args.multigpus_distributed and args.rank % args.num_gpus == 0):\\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \\n train_utils.save_model({\\n 'epoch': epoch + 1,\\n 'model_name': args.model_name,\\n 'state_dict': model.module.state_dict(),\\n 'optimizer': optimizer.state_dict(),\\n 'best_acc1': best_acc1,\\n 'loss': losses\\n }, is_best, args.model_chkpt_dir, args.model_dir)\\n elif not args.multigpus_distributed:\\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \\n train_utils.save_model({\\n 'epoch': epoch + 1,\\n 'model_name': args.model_name,\\n 'state_dict': model.state_dict(),\\n 'optimizer': optimizer.state_dict(),\\n 'best_acc1': best_acc1,\\n 'loss': losses\\n }, is_best, args.model_chkpt_dir, args.model_dir) \\n \\n \\n time_elapsed = time.time() - since\\n if current_gpu == 0:\\n logger.info('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\\n logger.info('Best val acc: {:.4f}'.format(best_acc1))\\n \\n if args.multigpus_distributed:\\n dist_cleanup()\",\n \"def train_model1(model, criterion, optimizer, scheduler, device, num_epochs=25):\\n since = time.time()\\n\\n best_model_wts = copy.deepcopy(model.state_dict())\\n best_acc = 0.0\\n model.to(device)\\n\\n for epoch in range(num_epochs):\\n print('Epoch {}/{}'.format(epoch, num_epochs - 1))\\n print('-' * 10)\\n\\n # Each epoch has a training and validation phase\\n for phase in ['train', 'val']:\\n if phase == 'train':\\n model.train() # Set model to training mode\\n else:\\n model.eval() # Set model to evaluate mode\\n\\n running_loss = 0.0\\n running_corrects = 0\\n\\n # Iterate over data.\\n for inputs, labels in dataloaders[phase]:\\n inputs = inputs.to(device)\\n labels = labels.to(device)\\n\\n # zero the parameter gradients\\n optimizer.zero_grad()\\n\\n # forward\\n # track history if only in train\\n with torch.set_grad_enabled(phase == 'train'):\\n outputs = model(inputs).squeeze(-1)\\n # if outputs.shape != labels.shape:\\n # print(outputs.shape)\\n # print(outputs.shape)\\n loss = criterion(outputs, labels)\\n # preds = outputs\\n # backward + optimize only if in training phase\\n if phase == 'train':\\n loss.backward()\\n optimizer.step()\\n\\n # statistics\\n running_loss += loss.item() * inputs.size(0)\\n # print(outputs.device, labels.to('cpu').device)\\n running_corrects += acc_calculate(outputs, labels)\\n # print(labels.data)\\n if phase == 'train':\\n scheduler.step()\\n\\n epoch_loss = running_loss / dataset_sizes[phase]\\n epoch_acc = running_corrects.double() / dataset_sizes[phase]\\n\\n print('{} Loss: {:.4f} Acc: {:.4f}'.format(\\n phase, epoch_loss, epoch_acc))\\n\\n # deep copy the model\\n if phase == 'val' and epoch_acc > best_acc:\\n best_acc = epoch_acc\\n best_model_wts = copy.deepcopy(model.state_dict())\\n\\n print()\\n\\n time_elapsed = time.time() - since\\n print('Training complete in {:.0f}m {:.0f}s'.format(\\n time_elapsed // 60, time_elapsed % 60))\\n print('Best val Acc: {:4f}'.format(best_acc))\\n\\n # load best model weights\\n model.load_state_dict(best_model_wts)\\n return model,best_acc\",\n \"def main(cfg):\\n # logging.info(f'Found base dir {cfg.BASE_DIR}')\\n\\n rng = cfg.experiment.random_seed\\n if rng == -1:\\n rng = np.random.randint(0, 1000)\\n\\n if rng is not False:\\n np.random.seed(rng)\\n torch.torch.manual_seed(rng)\\n\\n dcc = cfg.dataset.get('creation_args', dict())\\n if dcc.get('dim_normalise_mean', False):\\n dim = dcc.dim\\n dcc.f_mean = float(dcc.f_mean / np.sqrt(dim))\\n dcc.p_mean = float(dcc.p_mean / np.sqrt(dim))\\n logging.info(\\n f'Updating means in dataset cfg: {cfg.dataset.creation_args}')\\n\\n stats = dict(\\n dir=os.getcwd(),\\n host=socket.gethostname(),\\n job_id=os.getenv(\\\"SLURM_JOB_ID\\\", None),\\n random_state=rng)\\n STATS_STATUS = False\\n\\n logging.info(\\n f'Logging to {stats[\\\"dir\\\"]} on {stats[\\\"host\\\"]} '\\n f'for id={cfg.get(\\\"id\\\", -1)}')\\n\\n logging.info(f'Slurm job: {stats[\\\"job_id\\\"]}.')\\n logging.info(f'Setting random seed to {rng}.')\\n logging.info(f'Uniform clip val is {cfg.acquisition.uniform_clip}.')\\n\\n hoover = Hoover(cfg.hoover)\\n\\n model = None\\n\\n # Right now this averages over both train and testing!\\n for run in range(cfg.experiment.n_runs):\\n if run % cfg.experiment.log_every == 0 or cfg.experiment.debug:\\n logging.info(f'Run {run} in {os.getcwd()} ****NEW RUN****')\\n if cuda := torch.cuda.is_available():\\n logging.info(f'Still using cuda: {cuda}.')\\n else:\\n logging.info('No cuda found!')\\n os.system('touch cuda_failure.txt')\\n\\n dataset = maps.dataset[cfg.dataset.name](\\n cfg.dataset, model_cfg=cfg.model)\\n\\n # Train model on training data.\\n if (not cfg.model.get('keep_constant', False)) or (model is None):\\n # default case\\n model = maps.model[cfg.model.name](cfg.model)\\n\\n # test_data = model.make_loader(dataset.test_data, train=False)\\n # loss = model.evaluate(model.model, test_data)\\n # logging.info(f'Model test loss is {loss}.')\\n\\n # train_data = model.make_loader(dataset.train_data, train=False)\\n # loss = model.evaluate(model.model, train_data)\\n # logging.info(f'Model train loss is {loss}.')\\n\\n model.fit(*dataset.train_data)\\n\\n loss = model.performance(\\n *dataset.test_data, dataset.cfg['task_type'])\\n # logging.info(\\n # f'Weights vs 1 : {np.sqrt(np.sum((model.model.coef_ - 1)**2))}')\\n\\n if cfg.experiment.get('constant_val_set', False):\\n add_val_idxs_to_cfg(cfg, model.val_idxs)\\n\\n if not STATS_STATUS:\\n STATS_STATUS = True\\n stats['loss'] = loss\\n to_json(stats, 'stats.json')\\n # test_data = model.make_loader(dataset.test_data, train=False)\\n # loss = model.evaluate(model.model, test_data)\\n # logging.info(f'Model test loss is {loss}.')\\n\\n # Always predict on test data again\\n # TODO: need to fix this for efficient prediction\\n if cfg.model.get('efficient', False):\\n logging.debug('Eficient prediction on test set.')\\n model = make_efficient(model, dataset)\\n\\n # if cfg.experiment.debug:\\n # Report train error\\n # logging.info('Model train error:')\\n # model.performance(\\n # *dataset.train_data, dataset.cfg.task_type)\\n\\n # if not check_valid(model, dataset):\\n # continue\\n\\n if run < cfg.experiment.save_data_until:\\n hoover.add_data(run, dataset.export())\\n\\n for acq_dict in cfg.acquisition_functions:\\n # Slightly unclean, but could not figure out how to make\\n # this work with Hydra otherwise\\n acquisition = list(acq_dict.keys())[0]\\n acq_cfg_name = list(acq_dict.values())[0]\\n\\n if cfg.experiment.debug:\\n logging.info(f'\\\\t Acquisition: {acquisition}')\\n\\n # Reset selected test_indices.\\n dataset.restart(acquisition)\\n\\n if (n := acq_cfg_name) is not None:\\n acq_config = cfg['acquisition_configs'][n]\\n else:\\n acq_config = None\\n\\n experiment = Experiment(\\n run, cfg, dataset, model, acquisition, acq_config)\\n\\n i = 0\\n while not experiment.finished:\\n i += 1\\n # print('debug', i)\\n if cfg.experiment.debug:\\n logging.info(\\n f'\\\\t Acquisition: {acquisition} – \\\\t Step {i}.')\\n\\n experiment.step(i)\\n\\n # Add config to name for logging.\\n if (n := acq_cfg_name) is not None:\\n acquisition = f'{acquisition}_{n}'\\n\\n # Extract results from acquisition experiment\\n hoover.add_results(run, acquisition, experiment.export_data())\\n\\n if run % cfg.experiment.get('save_every', 1e19) == 0:\\n logging.info('Intermediate save.')\\n hoover.save()\\n\\n logging.info('Completed all runs.')\\n hoover.save()\",\n \"def model(self):\\n\\n # write summaries\\n\\n i = keras.Input(self.s)\\n\\n\\n return keras.Model(inputs=[i], outputs=self.call(i))\",\n \"def model(self):\\n\\n # write summaries\\n\\n i = keras.Input(self.s)\\n\\n\\n return keras.Model(inputs=[i], outputs=self.call(i))\",\n \"def train():\\n\\n global_step = tf.Variable(0, name='global_step', trainable=False)\\n\\n # Get images and labels for blood_model.\\n blood_datasets = blood_model.inputs(eval_data=False)\\n\\n # randomize the inputs look\\n x, y_, data, keep_prob = blood_model.prepare_input()\\n\\n # build the convolution network\\n conv_output, _, _, _, _ = blood_model.inference(data, keep_prob)\\n # Calculate loss.\\n loss = blood_model.loss(conv_output, y_)\\n accuracy = blood_model.accuracy(conv_output, y_)\\n\\n train_op = blood_model.train(loss, global_step)\\n\\n sess = tf.InteractiveSession()\\n\\n sess.run(tf.initialize_all_variables())\\n\\n # Build the summary operation based on the TF collection of Summaries.\\n summary_op = tf.merge_all_summaries()\\n\\n saver = tf.train.Saver()\\n\\n check_filesystem()\\n\\n train_writer = tf.train.SummaryWriter(FLAGS.summaries_dir + '/train', sess.graph)\\n validation_writer = tf.train.SummaryWriter(FLAGS.summaries_dir + '/validation', sess.graph)\\n test_writer = tf.train.SummaryWriter(FLAGS.summaries_dir + '/test', sess.graph)\\n\\n _ = reload_checkpoint_if_exists(sess, saver, train_writer, validation_writer, test_writer)\\n for step in range(tf.train.global_step(sess, global_step)+1, FLAGS.max_steps):\\n batch = blood_datasets.train.next_batch()\\n _, loss_output = sess.run([train_op, loss], feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})\\n assert not np.isnan(loss_output)\\n if step % 100 == 0:\\n summary, train_accuracy = sess.run([summary_op, accuracy], feed_dict={\\n x: batch[0], y_: batch[1], keep_prob: 1.0})\\n train_writer.add_summary(summary, step)\\n print(\\\"step %d, training accuracy %g, loss %g\\\" % (step, train_accuracy, loss_output))\\n\\n if (step % 1000 == 0 or (step + 1) == FLAGS.max_steps) and not step == 0:\\n batch = blood_datasets.validation.next_batch()\\n summary_validation, accuracy_validation = sess.run([summary_op, accuracy], feed_dict={\\n x: batch[0], y_: batch[1], keep_prob: 1.0})\\n validation_writer.add_summary(summary_validation, step)\\n print(\\\"validation accuracy %g\\\" % accuracy_validation)\\n\\n # save checkpoint\\n checkpoint_path = os.path.join(FLAGS.checkpoint_dir, 'model.ckpt')\\n saver.save(sess, checkpoint_path, global_step=step)\\n print(\\\"saving checkpoint\\\")\",\n \"def set_model(self, model):\\r\\n self.model = model.model\\r\\n with context.eager_mode():\\r\\n self._close_writers()\\r\\n if self.write_graph:\\r\\n with self._get_writer(self._train_run_name).as_default():\\r\\n with summary_ops_v2.always_record_summaries():\\r\\n if not self.model.run_eagerly:\\r\\n summary_ops_v2.graph(K.get_graph(), step=0)\\r\\n\\r\\n summary_writable = (\\r\\n self.model._is_graph_network or # pylint: disable=protected-access\\r\\n self.model.__class__.__name__ == 'Sequential') # pylint: disable=protected-access\\r\\n if summary_writable:\\r\\n summary_ops_v2.keras_model('keras', self.model, step=0)\\r\\n\\r\\n if self.embeddings_freq:\\r\\n self._configure_embeddings()\",\n \"def train(self):\\n\\n # Ensure everything is sent to GPU if being trained on the cloud\\n if self.local == False:\\n torch.set_default_tensor_type(torch.cuda.FloatTensor)\\n print(\\\"\\\\n \\\\n EVERYTHING TO CUDA \\\\n \\\\n\\\")\\n\\n # Load weights if applicable\\n if self.load_weights == True:\\n start_epoch, loss = self.load_checkpoint(\\n self.model, self.optimizer, self.model_name\\n )\\n start_epoch += 1\\n print(\\\"\\\\n \\\\n [WEIGHTS LOADED]\\\")\\n else:\\n start_epoch = 0\\n\\n # Start Training Loop\\n for epoch in range(start_epoch, self.epochs + 1):\\n\\n # TRAIN\\n if epoch > 0:\\n\\n # Set model to training mode\\n self.model.train()\\n\\n # Initialize loss and counter that will allow model weights to be saved and overwritten every 10 minibatches\\n train_loss = 0\\n counter = 0\\n\\n # Iterate through train set\\n for (\\n image1,\\n image2,\\n annotation1,\\n annotation2,\\n landmark1,\\n landmark2,\\n ) in tqdm(self.train_loader, desc=\\\"Train Epoch \\\" + str(epoch)):\\n\\n # image tensors and bounding box and label tensors to device\\n image1 = image1.to(self.device)\\n image2 = image2.to(self.device)\\n\\n # Forward pass of model\\n x1_hat, x2_hat, z1, z2 = self.model(image1, image2)\\n\\n # Calculate loss from one pass and append to training loss\\n loss = self.loss_fcn(\\n image1, image2, x1_hat, x2_hat, z1.detach(), z2.detach()\\n )\\n train_loss += loss.item()\\n\\n # Clear optimizer gradient\\n self.optimizer.zero_grad()\\n\\n # Backprop\\n loss.backward()\\n\\n # Take a step with optimizer\\n self.optimizer.step()\\n\\n # Save/overwrite model weights every 10 minibatches\\n if counter % 10 == 0:\\n self.save_checkpoint(\\n self.model,\\n self.optimizer,\\n self.model_name,\\n epoch,\\n train_loss,\\n )\\n\\n print(\\n f\\\"====> Epoch: {epoch} Average train loss: {train_loss / len(self.train_loader.dataset):.4f}\\\\n\\\"\\n )\\n\\n # Save entire model as .pt after every epoch of training\\n if self.local == True:\\n torch.save(\\n self.model,\\n os.path.join(self.save_path, self.model_name + \\\".pt\\\"),\\n )\\n else:\\n torch.save(\\n self.model, self.model_name + \\\"_epoch\\\" + str(epoch) + \\\".pt\\\"\\n )\\n print(\\\"SAVED MODEL EPOCH \\\" + str(epoch))\\n\\n # Evaluate on Validation Set after each epoch\\n with torch.no_grad():\\n\\n # Set model to evaluation mode\\n self.model.eval()\\n\\n # Iterate through validation set\\n for image1, image2, annotation1, annotation2 in tqdm(\\n self.val_loader, desc=\\\"Validation Epoch \\\" + str(epoch)\\n ):\\n\\n # Initialize validation loss\\n val_loss = 0\\n\\n # Send images to device\\n image1 = image1.to(self.device)\\n image2 = image2.to(self.device)\\n\\n # Forward pass of model\\n x1_hat, x2_hat, z1, z2 = self.model(image1, image2)\\n\\n # Calculate loss and append to validation loss\\n loss = self.loss_fcn(\\n image1, image2, x1_hat, x2_hat, z1.detach(), z2.detach()\\n )\\n val_loss += loss\\n\\n print(\\n f\\\"====> Epoch: {epoch} Average test loss: {val_loss / len(self.val_loader.dataset):.4f}\\\\n\\\"\\n )\\n\\n print(\\\"[DONE EPOCH{}]\\\".format(epoch))\\n\\n print(\\\"[DONE TRAINING]\\\")\\n\\n # Save model after all epochs are finished\\n if self.local == True:\\n torch.save(\\n self.model, os.path.join(self.save_path, self.model_name + \\\".pt\\\")\\n )\\n else:\\n torch.save(self.model, self.model_name + \\\".pt\\\")\",\n \"def model_train(fold_name, model_dir, model_dict, dataset_path, development_subj, mu, sigma):\\n valid_frames_before=200\\n valid_frames_after=0\\n valid_batch_size=8\\n generators = TXT_Train_Validation_Generators(dataset_path=dataset_path, subject_list=development_subj, train_size=model_dict[\\\"train_set_ratio\\\"], frames_before=model_dict[\\n \\\"frames\\\"]-model_dict[\\\"frame_shift\\\"], frames_after=model_dict[\\\"frame_shift\\\"], view_IDs=model_dict[\\\"view_IDs\\\"], batch_size=model_dict[\\\"batch_size\\\"], mu=mu, sigma=sigma, label_name=model_dict[\\\"label_name\\\"], shuffle=True,\\n valid_frames_before=valid_frames_before, valid_frames_after=valid_frames_after, valid_batch_size=valid_batch_size)\\n train_gen, valid_gen = generators.get_train(), generators.get_valid()\\n losses = Losses_Keras(\\n frames=model_dict['frames'], frame_shift=model_dict['frame_shift'])\\n loss_fnc = losses.get_by_name(model_dict[\\\"loss_function\\\"])\\n ap_metrics = [AUC_AP(), Accuracy_AP(), Precision_AP(),\\n Recall_AP(), PrecisionAtRecall_AP(0.95)]\\n fp_hdf5 = os.path.join(model_dir, fold_name+\\\".hdf5\\\")\\n fp_hdf5 = os.path.join(model_dir, fold_name+\\\".hdf5\\\")\\n mcp = ModelCheckpoint(fp_hdf5, monitor='val_loss', verbose=True,\\n save_best_only=True, save_weights_only=True)\\n tbl = tensorflow.keras.callbacks.TensorBoard(os.path.join(model_dir, 'logs{}'.format(fold_name)))\\n metrics = ap_metrics\\n callbacks = [mcp, tbl]\\n optimizer = tensorflow.keras.optimizers.Adam(learning_rate=model_dict['learning_rate'])\\n epochs = model_dict[\\\"epochs\\\"]\\n #### 1\\n compile_kwargs = {\\\"loss\\\": loss_fnc,\\n \\\"optimizer\\\": optimizer, \\\"metrics\\\": metrics}\\n fit_kwargs = {\\\"x\\\": train_gen, \\\"epochs\\\": epochs,\\n \\\"validation_data\\\": valid_gen, \\\"callbacks\\\": callbacks}\\n Setup = SETUP_DIC[model_dict[\\\"architecture\\\"]]\\n setup = Setup(name=model_dict[\\\"name\\\"], compile_kwargs=compile_kwargs, fit_kwargs=fit_kwargs,\\n TPA_view_IDs=model_dict['view_IDs'])\\n # setup.delete_existing_model_data_and_output()\\n print(setup.model.summary())\\n\\n setup.train()\\n setup.write_architecture()\\n # setup.plot_metrics(plot_val_metrics=valid_gen)\\n #### /1\\n #### 2\\n # Get optimal threshold.\\n print(\\\"Getting optimal threshold...\\\")\\n # RELOAD\\n data_models_model_path = setup.data_models_model_path\\n setup = Model_Evaluation(data_models_model_path, fold_name=fold_name,\\n stateful=False, weights_ext=\\\"hdf5\\\", load_scaling=False)\\n\\n # https://support.sas.com/en/books/reference-books/analyzing-receiver-operating-characteristic-curves-with-sas/review.html\\n # Gonen, Mithat. 2007. Analyzing Receiver Operating Characteristic Curves with SAS. Cary, NC: SAS Institute Inc.\\n preds_list, trues_list = [], []\\n # generators = [train_gen, valid_gen] if valid_gen else [train_gen]\\n generators = [valid_gen] if valid_gen else [train_gen]\\n for generator in generators:\\n for i in range(len(generator)):\\n x, y = generator[i]\\n preds_list.append(setup.model.predict(x))\\n trues_list.append(y)\\n preds = np.vstack(preds_list)\\n trues = np.vstack(trues_list)\\n labels_dict, predictions_dict = {}, {}\\n for idx, l in enumerate(zip(preds, trues)):\\n pred, true = l\\n predictions_dict[idx] = pred[:, 1]\\n sample_class = true[-1][-1]\\n labels_dict[idx] = model_dict[\\\"frames\\\"] - \\\\\\n model_dict[\\\"frame_shift\\\"] if sample_class else -1\\n if valid_gen:\\n labels_dict[idx] = valid_frames_before if sample_class else -1\\n prc_pre_fpr, prc_pre_tpr, prc_pre_thresholds = plots.prediction_pr_curve(\\n labels_dict, predictions_dict)\\n # get optimal threshold\\n fpr, tpr, thresh = prc_pre_fpr[:-1], prc_pre_tpr[:-1], prc_pre_thresholds\\n xy = np.stack([fpr, tpr]).T\\n ideal = np.array([1, 1])\\n d = ideal-xy\\n D = (d*d).sum(axis=-1)\\n optimal_threshold = thresh[D.argmin()]\\n with open(os.path.join(data_models_model_path, project.THRESHOLD_FILE_PATTERN.format(fold_name)), \\\"wb\\\") as f:\\n pickle.dump(optimal_threshold, f)\\n #### /2\\n print(\\\"Trained {}\\\".format(model_dict[\\\"name\\\"]))\\n clear_session()\\n return True\",\n \"def model(self, hyperparams, test_mode=False):\\n run_doc = OrderedDict() # Document important hyperparameters\\n run_start_time = time.time()\\n run_id = str(uuid4())\\n # TODO: Not ideal: Loads from memory every time. Use generator?\\n train_data, train_targets, test_data, test_targets = \\\\\\n self.data_loader(dataset=hyperparams['dataset'], size=hyperparams['dataset_size'])\\n run_doc['dataset'] = hyperparams['dataset']\\n run_doc['data_size'] = len(train_targets)\\n # Visualization tools\\n if config.INPUT_DEBUG:\\n image_analysis(image=train_data[0, :, :, :], label=train_targets[0, :])\\n # Input shape comes from image shape\\n img_width = train_data[0].shape[0]\\n img_height = train_data[0].shape[1]\\n num_channels = train_data[0].shape[2]\\n input_shape = (img_width, img_height, num_channels)\\n run_doc['input_shape'] = '(%d, %d, %d)' % input_shape\\n input_tensor = Input(shape=input_shape, dtype='float32', name='input_image')\\n try: # Model creation is in separate file\\n x, run_doc = custom_model(input_tensor, params=hyperparams, run_doc=run_doc)\\n except ValueError as e:\\n if not test_mode: # If not testing, ignore error causing models\\n return {'loss': 100, 'status': STATUS_OK}\\n else:\\n raise e\\n # Final layer classifies into 4 possible actions\\n output = layers.Dense(4, activation='softmax')(x)\\n # File names for the model and logs\\n log_file = os.path.join(self._logs_dir, run_id)\\n model_file = os.path.join(self._models_dir, run_id + '.h5')\\n # Add some callbacks so we can track progress using Tensorboard\\n callbacks = [keras.callbacks.EarlyStopping('val_loss', patience=config.TRAIN_PATIENCE, mode=\\\"min\\\")]\\n if not test_mode: # Don't save models/logs if in testing mode\\n callbacks += [keras.callbacks.TensorBoard(log_dir=log_file),\\n keras.callbacks.ModelCheckpoint(model_file, save_best_only=True)]\\n # Choice of optimizer and optimization parameters\\n if hyperparams['optimizer'] == 'sgd':\\n optimizer = optimizers.SGD(lr=hyperparams[\\\"learning_rate\\\"],\\n decay=hyperparams[\\\"decay\\\"],\\n clipnorm=hyperparams[\\\"clipnorm\\\"])\\n elif hyperparams['optimizer'] == 'rmsprop':\\n optimizer = optimizers.RMSprop(lr=hyperparams[\\\"learning_rate\\\"],\\n decay=hyperparams[\\\"decay\\\"],\\n clipnorm=hyperparams[\\\"clipnorm\\\"])\\n elif hyperparams['optimizer'] == 'nadam':\\n optimizer = optimizers.Nadam(lr=hyperparams[\\\"learning_rate\\\"],\\n schedule_decay=hyperparams[\\\"decay\\\"],\\n clipnorm=hyperparams[\\\"clipnorm\\\"])\\n elif hyperparams['optimizer'] == 'adam':\\n optimizer = optimizers.Adam(lr=hyperparams[\\\"learning_rate\\\"],\\n decay=hyperparams[\\\"decay\\\"],\\n clipnorm=hyperparams[\\\"clipnorm\\\"])\\n # Save optimizer parameters to run doc\\n run_doc['optimizer'] = hyperparams['optimizer']\\n run_doc['opt_learning_rate'] = hyperparams[\\\"learning_rate\\\"]\\n run_doc['opt_decay'] = hyperparams[\\\"decay\\\"]\\n run_doc['opt_clipnorm'] = hyperparams[\\\"clipnorm\\\"]\\n # Create and compile the model\\n model = Model(input_tensor, output)\\n model.compile(loss='categorical_crossentropy',\\n optimizer=optimizer,\\n metrics=['accuracy'])\\n # Print out model summary and store inside run documentation as list of strings\\n model.summary()\\n run_doc['model_summary'] = []\\n model.summary(print_fn=(lambda a: run_doc['model_summary'].append(a)))\\n # Fit the model to the datasets\\n self.log.info(\\\"Fitting model (eval %d of %d) ...\\\" % (self._eval_idx + 1, self._max_eval))\\n self._eval_idx += 1\\n model.fit(x=train_data, y=train_targets,\\n batch_size=hyperparams['batch_size'],\\n epochs=hyperparams['epochs'],\\n validation_data=(test_data, test_targets),\\n callbacks=callbacks,\\n verbose=1)\\n val_loss, val_acc = model.evaluate(x=test_data, y=test_targets, verbose=2)\\n self.log.info(\\\" .... Completed!\\\")\\n self.log.info(\\\" -- Evaluation time %ds\\\" % (time.time() - run_start_time))\\n self.log.info(\\\" -- Total time %ds\\\" % (time.time() - self._start_time))\\n # Save training parameters to run doc\\n run_doc['batch_size'] = hyperparams['batch_size']\\n run_doc['epochs'] = hyperparams['epochs']\\n run_doc['val_loss'] = val_loss\\n run_doc['val_acc'] = val_acc\\n # Results are used to pick best pirate\\n self._results[run_id] = val_loss\\n # Save run_doc to pickle file in model directory\\n run_doc_file_name = run_id + '.pickle'\\n if not test_mode: # Don't save docs if in testing mode\\n with open(os.path.join(self._models_dir, run_doc_file_name), 'wb') as f:\\n pickle.dump(run_doc, f)\\n self.log.info('Run Dictionary %s' % str(run_doc))\\n # Delete the session to prevent GPU memory from getting full\\n keras.backend.clear_session()\\n # Optimizer minimizes validation loss\\n return {'loss': val_loss, 'status': STATUS_OK}\",\n \"def train_on_one_batch(self):\\n save_model_path = './savedModel/cnn-model'\\n self.build_graph(save_model_path)\\n\\n with tf.device('/gpu:0'):\\n tf.reset_default_graph()\\n with tf.Session(graph=tf.get_default_graph()) as sess: #config=tf.ConfigProto(log_device_placement=True)\\n try:\\n graph = self.__load_graph(sess, save_model_path)\\n self.__train_and_report(sess, graph, range(1, 2), save_model_path)\\n\\n except Exception as e:\\n logger.error(\\\"Something is missing from the previous saved graph, remove it and regenerate graph\\\")\\n shutil.rmtree(\\\"./savedModel\\\")\\n exit()\",\n \"def build_model(self):\\r\\n self.images, self.labels = self.dataloader.get_model_inputs()\\r\\n\\r\\n model = SimpleModel(self.images, self.labels, output_dim=F.output_dim, scope='source_regressor')\\r\\n self.out, _ = model.get_model()\\r\\n self.get_loss()\",\n \"def build_model(self):\\n self.G = Generator(self.g_conv_dim)\\n self.D = Discriminator(self.d_conv_dim, self.c_dim)\\n self.generator = Generator(self.g_conv_dim).train(False)\\n\\n self.G = nn.DataParallel(self.G)\\n self.D = nn.DataParallel(self.D)\\n\\n # For Adam (Unofficial)\\n # self.g_optimizer = torch.optim.Adam(self.G.parameters(), self.g_lr, [self.beta1, self.beta2])\\n # self.d_optimizer = torch.optim.Adam(self.D.parameters(), self.d_lr, [self.beta1, self.beta2])\\n\\n # For RMSprop(Official)\\n self.g_optimizer = torch.optim.RMSprop(self.G.parameters(), lr=0.0001)\\n self.d_optimizer = torch.optim.RMSprop(self.D.parameters(), lr=0.0001)\\n\\n self.accumulate(self.generator, self.G.module, 0)\\n # self.print_network(self.G, 'G')\\n # self.print_network(self.D, 'D')\\n \\n self.G.to(self.device)\\n self.D.to(self.device)\\n self.generator.to(self.device)\\n\\n # weight init\\n self.G.apply(self.weights_init)\\n self.D.apply(self.weights_init)\\n self.generator.apply(self.weights_init)\",\n \"def test(model, dataloader, params, args, val):\\n\\n # evaluation mode\\n model.eval()\\n\\n # initialise buffers\\n dice_lv_buffer = []\\n dice_myo_buffer = []\\n dice_rv_buffer = []\\n\\n mcd_lv_buffer = []\\n hd_lv_buffer = []\\n mcd_myo_buffer = []\\n hd_myo_buffer = []\\n mcd_rv_buffer = []\\n hd_rv_buffer = []\\n\\n mean_mag_grad_detJ_buffer = []\\n negative_detJ_buffer = []\\n\\n\\n with tqdm(total=len(dataloader)) as t:\\n # iterate over validation subjects\\n for idx, (image_ed_batch, image_es_batch, label_ed_batch, label_es_batch) in enumerate(dataloader):\\n # (data all in shape of (c, N, H, W))\\n\\n # extend to (N, c, H, W)\\n image_ed_batch = image_ed_batch.permute(1, 0, 2, 3).to(device=args.device)\\n image_es_batch = image_es_batch.permute(1, 0, 2, 3).to(device=args.device)\\n label_es_batch = label_es_batch.permute(1, 0, 2, 3).to(device=args.device)\\n\\n with torch.no_grad():\\n # compute optical flow and warped ED images towards ES\\n dvf = model(image_ed_batch, image_es_batch)\\n\\n # transform label mask of ES frame\\n warped_label_es_batch = resample_transform(label_es_batch.float(), dvf, interp='nearest')\\n\\n\\n \\\"\\\"\\\" Move data to device \\\"\\\"\\\"\\n if args.cuda:\\n # move data to cpu to calculate metrics\\n # (the axis permutation is to comply with metric calculation code which takes input shape H, W, N)\\n warped_label_es_batch = warped_label_es_batch.squeeze(1).cpu().numpy().transpose(1, 2, 0)\\n label_ed_batch = label_ed_batch.squeeze(0).numpy().transpose(1, 2, 0)\\n dvf = dvf.data.cpu().numpy().transpose(0, 2, 3, 1) # (N, H, W, 2)\\n else:\\n # CPU version of the code\\n warped_label_es_batch = warped_label_es_batch.squeeze(1).numpy().transpose(1, 2, 0)\\n label_ed_batch = label_ed_batch.squeeze(0).numpy().transpose(1, 2, 0)\\n dvf = dvf.data.numpy().transpose(0, 2, 3, 1) # (N, H, W, 2)\\n \\\"\\\"\\\"\\\"\\\"\\\"\\n\\n \\\"\\\"\\\" Calculate the metrics (only works with SAX images) \\\"\\\"\\\"\\n # (optional) extract 3 slices (apical, mid-ventricle and basal)\\n if not args.all_slices:\\n num_slices = label_ed_batch.shape[-1]\\n apical_idx = int(round((num_slices - 1) * 0.75)) # 75% from basal\\n mid_ven_idx = int(round((num_slices - 1) * 0.5)) # 50% from basal\\n basal_idx = int(round((num_slices - 1) * 0.25)) # 25% from basal\\n slices_idx = [apical_idx, mid_ven_idx, basal_idx]\\n\\n warped_label_es_batch = warped_label_es_batch[:, :, slices_idx]\\n label_ed_batch = label_ed_batch[:, :, slices_idx]\\n dvf = dvf[slices_idx, :, :, :] # needed for detJac\\n\\n # dice\\n dice_lv = categorical_dice_stack(warped_label_es_batch, label_ed_batch, label_class=1)\\n dice_myo = categorical_dice_stack(warped_label_es_batch, label_ed_batch, label_class=2)\\n dice_rv = categorical_dice_stack(warped_label_es_batch, label_ed_batch, label_class=3)\\n\\n dice_lv_buffer += [dice_lv]\\n dice_myo_buffer += [dice_myo]\\n dice_rv_buffer += [dice_rv]\\n\\n # contour distances\\n mcd_lv, hd_lv = contour_distances_stack(warped_label_es_batch, label_ed_batch, label_class=1, dx=params.pixel_size)\\n mcd_myo, hd_myo = contour_distances_stack(warped_label_es_batch, label_ed_batch, label_class=2, dx=params.pixel_size)\\n mcd_rv, hd_rv = contour_distances_stack(warped_label_es_batch, label_ed_batch, label_class=3, dx=params.pixel_size)\\n\\n # determinant of Jacobian\\n mean_grad_detJ, mean_negative_detJ = detJac_stack(dvf)\\n\\n\\n # update buffers\\n mcd_lv_buffer += [mcd_lv]\\n hd_lv_buffer += [hd_lv]\\n mcd_myo_buffer += [mcd_myo]\\n hd_myo_buffer += [hd_myo]\\n mcd_rv_buffer += [mcd_rv]\\n hd_rv_buffer += [hd_rv]\\n\\n mean_mag_grad_detJ_buffer += [mean_grad_detJ]\\n negative_detJ_buffer += [mean_negative_detJ]\\n\\n t.update()\\n\\n # construct metrics dict\\n metrics = {'dice_lv_mean': np.mean(dice_lv_buffer), 'dice_lv_std': np.std(dice_lv_buffer),\\n 'dice_myo_mean': np.mean(dice_myo_buffer), 'dice_myo_std': np.std(dice_myo_buffer),\\n 'dice_rv_mean': np.mean(dice_rv_buffer), 'dice_rv_std': np.std(dice_rv_buffer),\\n\\n 'mcd_lv_mean': np.mean(mcd_lv_buffer), 'mcd_lv_std': np.std(mcd_lv_buffer),\\n 'mcd_myo_mean': np.mean(mcd_myo_buffer), 'mcd_myo_std': np.std(mcd_myo_buffer),\\n 'mcd_rv_mean': np.mean(mcd_rv_buffer), 'mcd_rv_std': np.std(mcd_rv_buffer),\\n\\n 'hd_lv_mean': np.mean(hd_lv_buffer), 'hd_lv_std': np.std(hd_lv_buffer),\\n 'hd_myo_mean': np.mean(hd_myo_buffer), 'hd_myo_std': np.std(hd_myo_buffer),\\n 'hd_rv_mean': np.mean(hd_rv_buffer), 'hd_rv_std': np.std(hd_rv_buffer),\\n\\n 'mean_mag_grad_detJ_mean': np.mean(mean_mag_grad_detJ_buffer),\\n 'mean_mag_grad_detJ_std': np.std(mean_mag_grad_detJ_buffer),\\n\\n 'negative_detJ_mean': np.mean(negative_detJ_buffer),\\n 'negative_detJ_std': np.std(negative_detJ_buffer)\\n }\\n\\n\\n if not val:\\n # testing only: save all metrics evaluated for all test subjects in pandas dataframe\\n test_result_dir = os.path.join(args.model_dir, \\\"test_results\\\")\\n if not os.path.exists(test_result_dir):\\n os.makedirs(test_result_dir)\\n\\n # save metrics results mean & std\\n xutils.save_dict_to_json(metrics,\\n f\\\"{test_result_dir}/test_results_3slices_{not args.all_slices}.json\\\")\\n\\n # save accuracy metrics of every subject\\n subj_id_buffer = dataloader.dataset.dir_list\\n df_buffer = []\\n column_method = ['DL'] * len(subj_id_buffer)\\n for struct in ['LV', 'MYO', 'RV']:\\n if struct == 'LV':\\n ls_dice = dice_lv_buffer\\n ls_mcd = mcd_lv_buffer\\n ls_hd = hd_lv_buffer\\n elif struct == 'MYO':\\n ls_dice = dice_myo_buffer\\n ls_mcd = mcd_myo_buffer\\n ls_hd = hd_myo_buffer\\n elif struct == 'RV':\\n ls_dice = dice_rv_buffer\\n ls_mcd = mcd_rv_buffer\\n ls_hd = hd_rv_buffer\\n\\n ls_struct = [struct] * len(subj_id_buffer)\\n data = {'Method': column_method,\\n 'ID': subj_id_buffer,\\n 'Structure': ls_struct,\\n 'Dice': ls_dice,\\n 'MCD': ls_mcd,\\n 'HD': ls_hd}\\n df_buffer += [pd.DataFrame(data=data)]\\n # concatenate df and save\\n metrics_df = pd.concat(df_buffer, axis=0)\\n metrics_df.to_pickle(f\\\"{test_result_dir}/test_accuracy_results_3slices_{not args.all_slices}.pkl\\\")\\n\\n # save detJac metrics for every subject\\n jac_data = {'Method': column_method,\\n 'ID': subj_id_buffer,\\n 'GradDetJac': mean_mag_grad_detJ_buffer,\\n 'NegDetJac': negative_detJ_buffer}\\n jac_df = pd.DataFrame(data=jac_data)\\n jac_df.to_pickle(f\\\"{test_result_dir}/test_Jacobian_results_3slices{not args.all_slices}.pkl\\\")\\n\\n return metrics\",\n \"def combineModelsAndExport(builderSpec, nmsSpec, fileName, quantize=False):\\n try:\\n print(f\\\"Combine CoreMl model with nms and export model\\\")\\n # Combine models to a single one\\n pipeline = ct.models.pipeline.Pipeline(\\n input_features=[\\n (\\\"image\\\", ct.models.datatypes.Array(3, 460, 460)),\\n (\\\"iouThreshold\\\", ct.models.datatypes.Double()),\\n (\\\"confidenceThreshold\\\", ct.models.datatypes.Double()),\\n ],\\n output_features=[\\\"confidence\\\", \\\"coordinates\\\"],\\n )\\n\\n # Required version (>= ios13) in order for mns to work\\n pipeline.spec.specificationVersion = 4\\n\\n pipeline.add_model(builderSpec)\\n pipeline.add_model(nmsSpec)\\n\\n pipeline.spec.description.input[0].ParseFromString(\\n builderSpec.description.input[0].SerializeToString()\\n )\\n pipeline.spec.description.output[0].ParseFromString(\\n nmsSpec.description.output[0].SerializeToString()\\n )\\n pipeline.spec.description.output[1].ParseFromString(\\n nmsSpec.description.output[1].SerializeToString()\\n )\\n\\n # Metadata for the model‚\\n pipeline.spec.description.input[\\n 1\\n ].shortDescription = \\\"(optional) IOU Threshold override (Default: 0.6)\\\"\\n pipeline.spec.description.input[\\n 2\\n ].shortDescription = \\\"(optional) Confidence Threshold override (Default: 0.4)\\\"\\n pipeline.spec.description.output[\\n 0\\n ].shortDescription = \\\"Boxes \\\\xd7 Class confidence\\\"\\n pipeline.spec.description.output[\\n 1\\n ].shortDescription = \\\"Boxes \\\\xd7 [x, y, width, height] (relative to image size)\\\"\\n pipeline.spec.description.metadata.versionString = \\\"1.0\\\"\\n pipeline.spec.description.metadata.shortDescription = \\\"yolov5\\\"\\n pipeline.spec.description.metadata.author = \\\"Leon De Andrade\\\"\\n pipeline.spec.description.metadata.license = \\\"\\\"\\n\\n model = ct.models.MLModel(pipeline.spec)\\n model.save(fileName)\\n\\n if quantize:\\n fileName16 = fileName.replace(\\\".mlmodel\\\", \\\"_16.mlmodel\\\")\\n modelFp16 = ct.models.neural_network.quantization_utils.quantize_weights(\\n model, nbits=16\\n )\\n modelFp16.save(fileName16)\\n\\n fileName8 = fileName.replace(\\\".mlmodel\\\", \\\"_8.mlmodel\\\")\\n modelFp8 = ct.models.neural_network.quantization_utils.quantize_weights(\\n model, nbits=8\\n )\\n modelFp8.save(fileName8)\\n\\n print(f\\\"CoreML export success, saved as {fileName}\\\")\\n except Exception as e:\\n print(f\\\"CoreML export failure: {e}\\\")\",\n \"def meta_train(tasks, model, args, device, method='random', meta_iters=10000, num_updates=5, meta_batch_size=5):\\n # Define logging\\n os.makedirs(args.save_path, exist_ok=True)\\n writer = SummaryWriter(\\n os.path.join(args.save_path, 'runs', '{}'.format(datetime.now()).replace(\\\":\\\", \\\"_\\\")))\\n\\n header = ' Time Task Iteration Loss Accuracy'\\n log_template = '{:>10} {:>25} {:10.0f} {:10.6f} {:10.6f}'\\n test_template = 'Test mean: {}, Test std: {}'\\n\\n print(header)\\n start = time.time()\\n\\n # Define optimizers, lr schedulers and loss function\\n optimizer_bert = AdamW(params=model.proto_net.encoder.bert.parameters(), lr=args.bert_lr)\\n optimizer = optim.Adam(params=chain(model.proto_net.encoder.mlp.parameters(),\\n model.output_layer.parameters()),\\n lr=args.lr)\\n scheduler_bert = get_cosine_schedule_with_warmup(optimizer_bert, 200, meta_iters)\\n scheduler = get_cosine_schedule_with_warmup(optimizer, 0, meta_iters)\\n # ProtoNets always have CrossEntropy loss due to softmax output\\n cross_entropy = nn.CrossEntropyLoss()\\n\\n print('Loading Tokenizer..')\\n tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)\\n special_tokens_dict = {'additional_special_tokens': [\\\"[MNT]\\\", \\\"[URL]\\\"]}\\n\\n num_added_toks = tokenizer.add_special_tokens(special_tokens_dict)\\n print('We have added', num_added_toks, 'tokens')\\n model.proto_net.encoder.bert.resize_token_embeddings(len(tokenizer))\\n # Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e. the length of the tokenizer.\\n\\n # setup task sampler and task model\\n sampler = TaskSampler(tasks, method=method, custom_task_ratio=args.custom_task_ratio, supp_query_split=True)\\n task_model = type(model)(args)\\n task_model.proto_net.encoder.bert.resize_token_embeddings(len(tokenizer))\\n\\n iterations = 0\\n # Iterate over the data\\n train_iter = sampler.get_iter('train', tokenizer, batch_size=args.batch_size, shuffle=True)\\n model.train()\\n\\n # setup validation task and episodes for evaluation\\n val_task = get_validation_task(args)\\n episodes = torch.load(args.episodes)\\n\\n # dummy data to overwrite old values of task model output layer\\n dummy_w = torch.randn((args.mlp_dims[-1], 2))\\n dummy_b = torch.randn(2)\\n\\n average_query_loss = 0\\n best_query_loss = 1e+9\\n best_test_mean = -1\\n best_test_last = -1\\n convergence_tolerance_cnt = 0\\n # outer loop (meta-iterations)\\n for i in range(meta_iters):\\n grads = []\\n task_losses_inner = {}\\n task_accuracies_inner = {}\\n task_losses_outer = {}\\n task_accuracies_outer = {}\\n # inner loop (sample different tasks)\\n for task_sample in range(meta_batch_size):\\n # clone original model\\n task_model.proto_net.load_state_dict(model.proto_net.state_dict())\\n task_model.initialize_classifier(nn.Parameter(dummy_w), nn.Parameter(dummy_b), hard_replace=True)\\n task_model.to(device)\\n task_model.train()\\n\\n # new optimizer for every new task model\\n task_optimizer_bert = optim.SGD(params=task_model.proto_net.encoder.bert.parameters(), lr=args.bert_lr)\\n task_optimizer = optim.SGD(params=chain(task_model.proto_net.encoder.mlp.parameters(),\\n task_model.output_layer.parameters()),\\n lr=args.inner_lr)\\n\\n # prepare support and query set\\n batch = next(train_iter)\\n support = batch[:3]\\n query = batch[3:]\\n\\n # setup output layer (via meta-model's prototype network)\\n proto_embeddings = model.proto_net(support[0].to(device), attention_mask=support[2].to(device))\\n prototypes = model.proto_net.calculate_centroids((proto_embeddings, support[1]), sampler.get_num_classes())\\n W, b = task_model.calculate_output_params(prototypes.detach())\\n task_model.initialize_classifier(W, b)\\n\\n # train some iterations on support set\\n for update in range(num_updates):\\n task_optimizer_bert.zero_grad()\\n task_optimizer.zero_grad()\\n predictions = task_model(support[0].to(device), attention_mask=support[2].to(device))\\n task_loss = cross_entropy(predictions, support[1].long().squeeze().to(device))\\n task_loss.backward()\\n task_optimizer.step()\\n task_optimizer_bert.step()\\n\\n # record task losses and accuracies for logging\\n task_losses_inner[sampler.get_name()] = task_loss.item()\\n task_accuracies_inner[sampler.get_name()] = sampler.calculate_accuracy(predictions, support[1].to(device))\\n\\n # trick to add prototypes back to computation graph\\n W = 2 * prototypes + (W - 2 * prototypes).detach()\\n b = -prototypes.norm(dim=1)**2 + (b + prototypes.norm(dim=1)**2).detach()\\n task_model.initialize_classifier(W, b, hard_replace=True)\\n\\n # calculate gradients for meta update on the query set\\n predictions = task_model(query[0].to(device), attention_mask=query[2].to(device))\\n query_loss = cross_entropy(predictions, query[1].long().squeeze().to(device))\\n query_loss.backward()\\n\\n # record task losses and accuracies for logging\\n task_losses_outer[sampler.get_name()] = query_loss.item()\\n task_accuracies_outer[sampler.get_name()] = sampler.calculate_accuracy(predictions, query[1].to(device))\\n average_query_loss += query_loss.item()\\n\\n # register W and b parameters again to avoid error in weight update\\n W = nn.Parameter(W)\\n b = nn.Parameter(b)\\n task_model.initialize_classifier(W, b, hard_replace=True)\\n\\n # save gradients of first task model\\n if task_sample == 0:\\n for param in task_model.parameters():\\n if param.requires_grad and param.grad is not None:\\n grads.append(param.grad.clone())\\n # add the gradients of all task samples\\n else:\\n p = 0\\n for param in task_model.parameters():\\n if param.requires_grad and param.grad is not None:\\n grads[p] += param.grad.clone()\\n p += 1\\n\\n # perform meta update\\n # first load/add the calculated gradients in the meta-model\\n # (already contains gradients from prototype calculation)\\n p = 0\\n for param in model.parameters():\\n if param.requires_grad and param.grad is not None:\\n param.grad += grads[p]\\n p += 1\\n # update model parameters according to the gradients from inner loop (clear gradients afterwards)\\n optimizer.step()\\n optimizer_bert.step()\\n scheduler.step()\\n scheduler_bert.step()\\n optimizer.zero_grad()\\n optimizer_bert.zero_grad()\\n\\n iterations += 1\\n if iterations % args.log_every == 0:\\n average_query_loss /= (args.log_every*meta_batch_size)\\n iter_loss = sum(task_losses_outer.values()) / len(task_losses_outer.values())\\n iter_acc = sum(task_accuracies_outer.values()) / len(task_accuracies_outer.values())\\n writer.add_scalar('Meta_Average/Loss/outer'.format(sampler.get_name()), iter_loss, iterations)\\n writer.add_scalar('Meta_Average/Accuracy/outer'.format(sampler.get_name()), iter_acc, iterations)\\n for t in tasks:\\n task_name = t.get_name()\\n if task_name in task_losses_inner.keys():\\n writer.add_scalar('{}/Loss/inner'.format(task_name), task_losses_inner[task_name], iterations)\\n writer.add_scalar('{}/Accuracy/inner'.format(task_name), task_accuracies_inner[task_name], iterations)\\n writer.add_scalar('{}/Loss/outer'.format(task_name), task_losses_outer[task_name], iterations)\\n writer.add_scalar('{}/Accuracy/outer'.format(task_name), task_accuracies_outer[task_name], iterations)\\n print(log_template.format(\\n str(timedelta(seconds=int(time.time() - start))),\\n sampler.get_name(),\\n iterations,\\n iter_loss,\\n iter_acc))\\n\\n # save best snapshot\\n if average_query_loss < best_query_loss:\\n best_query_loss = average_query_loss\\n average_query_loss = 0\\n snapshot_prefix = os.path.join(args.save_path, 'best_query')\\n snapshot_path = (\\n snapshot_prefix +\\n '_loss_{:.5f}_iter_{}_model.pt'\\n ).format(best_query_loss, iterations)\\n model.save_model(snapshot_path)\\n # Keep only the best snapshot\\n for f in glob.glob(snapshot_prefix + '*'):\\n if f != snapshot_path:\\n os.remove(f)\\n\\n # evaluate in k shot fashion\\n if iterations % args.eval_every == 0:\\n task_model.proto_net.load_state_dict(model.proto_net.state_dict())\\n task_model.initialize_classifier(nn.Parameter(dummy_w), nn.Parameter(dummy_b), hard_replace=True)\\n test_mean, test_std = k_shot_testing(task_model, episodes, val_task, device, num_updates=args.inner_updates,\\n num_test_batches=args.num_test_batches)\\n writer.add_scalar('{}/Acc'.format(val_task.get_name()), test_mean, iterations)\\n writer.add_scalar('{}/STD'.format(val_task.get_name()), test_std, iterations)\\n print(test_template.format(test_mean, test_std), flush=True)\\n if test_mean > best_test_mean:\\n best_test_mean = test_mean\\n snapshot_prefix = os.path.join(args.save_path, 'best_test_{}'.format(val_task.get_name()))\\n snapshot_path = (\\n snapshot_prefix +\\n '_acc_{:.5f}_iter_{}_model.pt'\\n ).format(best_test_mean, iterations)\\n model.save_model(snapshot_path)\\n # Keep only the best snapshot\\n for f in glob.glob(snapshot_prefix + '*'):\\n if f != snapshot_path:\\n os.remove(f)\\n \\n if test_mean > best_test_last:\\n best_test_last = best_test_mean\\n convergence_tolerance_cnt = 0\\n else:\\n convergence_tolerance_cnt += 1\\n\\n if convergence_tolerance_cnt == args.convergence_tolerance:\\n break\\n\\n\\n # saving redundant parameters\\n # Save model checkpoints.\\n if iterations % args.save_every == 0:\\n iter_loss = sum(task_losses_outer.values()) / len(task_losses_outer.values())\\n snapshot_prefix = os.path.join(args.save_path, 'snapshot')\\n snapshot_path = (\\n snapshot_prefix +\\n '_iter_{}_loss_{}_model.pt'\\n ).format(iterations, iter_loss)\\n logging.debug('Saving model...')\\n model.save_model(snapshot_path)\\n # Keep only the last snapshot\\n for f in glob.glob(snapshot_prefix + '*'):\\n if f != snapshot_path:\\n os.remove(f)\\n\\n writer.close()\",\n \"def build_model(self):\\n cfg = self.cfg\\n\\n print('Building model')\\n self.model = SimpleNet(cfg, cfg.MODEL, 0, **cfg.MODEL.BACKBONE.PARAMS)\\n self.model.to(self.device)\\n print('# params: {:,}'.format(count_num_param(self.model)))\\n self.optim = build_optimizer(self.model, cfg.OPTIM)\\n self.sched = build_lr_scheduler(self.optim, cfg.OPTIM)\\n self.register_model('model', self.model, self.optim, self.sched)\\n\\n fdim = self.model.fdim\\n self.classifier = nn.Linear(fdim, self.num_classes)\\n print('# params: {:,}'.format(count_num_param(self.classifier)))\\n self.classifier.to(self.device)\\n self.optim_classifier = build_optimizer(self.classifier, cfg.OPTIM)\\n self.sched_classifier = build_lr_scheduler(self.optim_classifier, cfg.OPTIM)\\n self.register_model('classifier', self.classifier, self.optim_classifier, self.sched_classifier)\",\n \"def make_model(self):\\n if self.model_type=='densenet_121':\\n model = self.make_densenet_121(self.weights)\\n\\n\\n return model\",\n \"def run_model(self):\\n hparams = self.hparams\\n\\n # Build the child graph\\n with tf.Graph().as_default(), tf.device(\\n '/cpu:0' if FLAGS.use_cpu else '/gpu:0'):\\n m, meval = self._build_models()\\n\\n # Figure out what epoch we are on\\n starting_epoch = self._calc_starting_epoch(m)\\n\\n # Run the validation error right at the beginning\\n valid_accuracy = self.eval_child_model(\\n meval, self.data_loader, 'val')\\n tf.logging.info('Before Training Epoch: {} Val Acc: {}'.format(\\n starting_epoch, valid_accuracy))\\n training_accuracy = None\\n\\n for curr_epoch in xrange(starting_epoch, hparams.num_epochs):\\n\\n # Run one training epoch\\n training_accuracy = self._run_training_loop(m, curr_epoch)\\n\\n valid_accuracy = self.eval_child_model(\\n meval, self.data_loader, 'val')\\n tf.logging.info('Epoch: {} Valid Acc: {}'.format(\\n curr_epoch, valid_accuracy))\\n\\n valid_accuracy, test_accuracy = self._compute_final_accuracies(\\n meval)\\n\\n tf.logging.info(\\n 'Train Acc: {} Valid Acc: {} Test Acc: {}'.format(\\n training_accuracy, valid_accuracy, test_accuracy))\",\n \"def _setup_summaries(self, sess):\\n # Output directory for models and summaries\\n\\n\\n print(\\\"Writing to {}\\\\n\\\".format(os.path.abspath(self._log_dir)))\\n\\n train_summary_dir = os.path.join(self._log_dir, \\\"summaries\\\", \\\"train\\\")\\n self._train_summary_writer = tf.summary.FileWriter(train_summary_dir, sess.graph)\\n\\n val_summary_dir = os.path.join(self._log_dir, \\\"summaries\\\", \\\"validation\\\")\\n self._val_summary_writer = tf.summary.FileWriter(val_summary_dir, sess.graph)\\n\\n # Model checkpoints\\n # Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it\\n self.checkpoint_dir = os.path.abspath(os.path.join(self._save_dir, \\\"checkpoints/\\\"))\\n\\n if not os.path.exists(self.checkpoint_dir):\\n os.makedirs(self.checkpoint_dir)\\n\\n self._saver = tf.train.Saver(max_to_keep=10) # Save model after each epoch\\n\\n self.train_summary_op = tf.summary.merge(self._train_summaries)\\n self.val_summary_op = tf.summary.merge(self._val_summaries)\\n\\n print(\\\"--------------------------------------------------\\\")\\n print(\\\"\\\\ntensorboard --logdir {}\\\".format(os.path.abspath(self._log_dir)))\\n print(\\\"\\\\ntensorboard --logdir {} --port 6007\\\".format(os.path.abspath(self.checkpoint_dir)))\\n print(\\\"--------------------------------------------------\\\")\",\n \"def _main():\\n\\n # setup paths\\n json_model_path = osp.join(FLAGS.input_dir, FLAGS.json_model_fname)\\n weights_path = osp.join(FLAGS.input_dir, FLAGS.weights_fname)\\n save_path = osp.splitext(json_model_path)[0][:-6] + \\\"graph_w\\\" + str(weights_path.split(\\\"_\\\")[-1][:-3]) + \\\".pb\\\"\\n print(\\\"Loading Model: \\\" + json_model_path)\\n print(\\\"Loading Weights: \\\" + weights_path)\\n\\n # Set keras to test phase\\n k.set_learning_phase(0)\\n\\n # Load json and weights, then compile model\\n with open(json_model_path, 'r') as json_file:\\n loaded_model_json = json_file.read()\\n model = model_from_json(loaded_model_json)\\n model.load_weights(weights_path)\\n model.compile(loss='mse', optimizer='sgd')\\n\\n # Freeze graph\\n frozen_graph = freeze_session(k.get_session(), output_names=[out.op.name for out in model.outputs])\\n\\n # Write graph to protobuf file\\n tf.train.write_graph(frozen_graph, \\\"model\\\", save_path, as_text=False)\\n print(\\\"Written Graph to: \\\" + save_path)\",\n \"def learn(model: KW_Model,\\n trainloader: DataLoader,\\n testloader: DataLoader,\\n optimizer: optim.Optimizer,\\n nb_epoch: int,\\n device: torch.device,\\n eval_fn: Callable[[List[bool], List[Qid]], Dict[Qid, float]],\\n mean_window: int = 50,\\n entropy_lambda: float = 0.025,\\n smt_lambda: float = 1.0,\\n reinforce_lambda: float = 1.0,\\n ) -> Tuple[nn.Module, Dict[str, List[torch.tensor]], Dict[str, List[torch.tensor]]]:\\n print(\\\"Memory usage: %s (kb)\\\" % resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)\\n past_rewards = {str(q_id.long().item()): deque(maxlen=mean_window)\\n for _, _, q_ids, _ in chain(trainloader, testloader)\\n for q_id in q_ids}\\n \\n logs = [\\\"reward\\\",\\n \\\"scaled_entropy\\\",\\n \\\"scaled_reinforce\\\",\\n \\\"scaled_smt\\\",\\n \\\"total_loss\\\",\\n \\\"accuracy\\\"]\\n train_logs = {log: list() for log in logs}\\n test_logs = {log: list() for log in logs}\\n del logs\\n \\n for epoch in range(nb_epoch):\\n running_loss, running_reward = [], []\\n entropies, reinforces, smts = [], [], []\\n nb_correct, nb_total = 0, 0\\n print(f\\\"\\\\nEpoch {epoch}\\\")\\n \\n print(\\\"Begin epoch: %s (kb)\\\" % resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)\\n model.train()\\n for x, y, q_id, masks in trainloader:\\n x = x.to(device)\\n y = y.to(device)\\n masks = masks.to(device)\\n\\n # batch x seq , batch x seq , batch x seq\\n sample, logits, entropy, params = model(x, masks)\\n batch_reward, rewards = eval_fn(sample.detach().t().tolist(), q_id)\\n losses = compute_losses(y, params, rewards, logits, past_rewards,\\n entropy, entropy_lambda, reinforce_lambda, smt_lambda, device)\\n\\n # entropy_lambda = min(1.01*entropy_lambda, 0.025)\\n # reinforce_lambda = min(1.01*reinforce_lambda, 1.0)\\n # smt_lambda = max(0.99*smt_lambda, 0.05)\\n loss, reinforce_loss, entropy, smt_loss = losses\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n \\n temp = (sample.long() == y.detach().long()).float() * masks\\n nb_correct += temp.byte().cpu().sum().tolist()\\n nb_total += masks.cpu().sum().tolist()\\n\\n running_loss.append(loss.item())\\n running_reward.extend(rewards.values())\\n print(f\\\"\\\\rTr Loss {mean(running_loss): .3f} Rewa {mean(running_reward): .5f}\\\", end=\\\"\\\")\\n \\n reinforces.append(reinforce_loss.item())\\n entropies.append(entropy.item())\\n smts.append(smt_loss.item())\\n\\n # Logs\\n train_logs[\\\"reward\\\"].append(mean(running_reward))\\n train_logs[\\\"scaled_entropy\\\"].append(mean(entropies))\\n train_logs[\\\"scaled_reinforce\\\"].append(mean(reinforces))\\n train_logs[\\\"scaled_smt\\\"].append(mean(smts))\\n train_logs[\\\"total_loss\\\"].append(mean(running_loss))\\n train_logs[\\\"accuracy\\\"].append(nb_correct / nb_total)\\n \\n \\n train_loss, train_reward = mean(running_loss), mean(running_reward)\\n running_loss, running_reward = [], []\\n entropies, reinforces, smts = [], [], []\\n nb_correct, nb_total = 0, 0\\n model.eval()\\n for x, y, q_id, masks in testloader:\\n x = x.to(device)\\n y = y.to(device)\\n masks = masks.to(device)\\n\\n # batch x seq , batch x seq , batch x seq\\n sample, logits, entropy, params = model(x, masks)\\n batch_reward, rewards = eval_fn(sample.detach().t().tolist(), q_id)\\n\\n losses = compute_losses(y, params, rewards, logits, past_rewards,\\n entropy, entropy_lambda, reinforce_lambda, smt_lambda, device)\\n loss, reinforce_loss, entropy, smt_loss = losses\\n \\n temp = (sample.long() == y.detach().long()).float() * masks\\n nb_correct += temp.byte().sum().tolist()\\n nb_total += masks.sum().tolist()\\n\\n running_loss.append(loss.item())\\n running_reward.extend(rewards.values())\\n print(f\\\"\\\\rTr Loss {train_loss: .3f} Rewa {train_reward: .3f}\\\",\\n f\\\"Te Loss{mean(running_loss): .3f} Rewa {mean(running_reward): .3f}\\\",\\n end=\\\"\\\")\\n \\n reinforces.append(reinforce_loss.item())\\n entropies.append(entropy.item())\\n smts.append(smt_loss.item())\\n \\n \\n # Logs\\n test_logs[\\\"reward\\\"].append(mean(running_reward))\\n test_logs[\\\"scaled_entropy\\\"].append(mean(entropies))\\n test_logs[\\\"scaled_reinforce\\\"].append(mean(reinforces))\\n test_logs[\\\"scaled_smt\\\"].append(mean(smts))\\n test_logs[\\\"total_loss\\\"].append(mean(running_loss))\\n test_logs[\\\"accuracy\\\"].append(nb_correct / nb_total)\\n \\n\\n return model, train_logs, test_logs\",\n \"def main(u_net_settings):\\n model = build_u_net(*u_net_settings)\\n print(model.summary())\",\n \"def __init__(self, conf):\\n self.model_conf = conf[\\\"model\\\"]\\n self.epochs = self.model_conf.getint(\\\"n_epochs\\\")\\n self.epoch = self.model_conf.getint(\\\"epoch_start\\\")\\n self.batch_size = self.model_conf.getint(\\\"batch_size\\\")\\n self.criterion = nn.CrossEntropyLoss()\\n self.device = torch.device(self.model_conf.get('device'))\\n #self.model = (\\n # eval(self.model_conf.get('name'))(self.model_conf).to(self.device)\\n #)\\n self.model = nn.DataParallel(\\n eval(self.model_conf.get('name'))(self.model_conf).to(self.device)\\n )\\n total_params = sum(p.numel() for p in self.model.parameters())\\n print(\\\"Created model {}: {} parameters\\\"\\n .format(self.model_conf.get('name'), total_params))\\n if self.model_conf.get(\\\"optim\\\") == 'SGD':\\n self.optimizer = optim.SGD(\\n self.model.parameters(),\\n lr=self.model_conf.getfloat(\\\"learning_rate\\\"),\\n momentum=self.model_conf.getfloat(\\\"momentum\\\"),\\n weight_decay=self.model_conf.getfloat(\\\"weight_decay\\\"))\\n elif self.model_conf.get(\\\"optim\\\") == 'Adam':\\n self.optimizer = optim.Adam(\\n self.model.parameters(),\\n lr=self.model_conf.getfloat(\\\"learning_rate\\\"),\\n betas=json.loads(self.model_conf.get(\\\"betas\\\")))\\n else:\\n raise ValueError('Only SGD is supported')\\n\\n if self.model_conf.get(\\\"checkpoint\\\") is not None:\\n self.load_checkpoint(self.model_conf.get(\\\"checkpoint\\\"))\\n\\n self.checkpoints_path = conf.get(\\\"paths\\\", \\\"checkpoints\\\")\\n self.results_path = conf.get(\\\"paths\\\", \\\"results\\\")\\n self.best_accuracy = 0\\n self.train_size = None\\n self.valid_size = None\\n self.iteration_print_freq = conf.getint(\\\"log\\\", \\\"iteration_print_freq\\\")\",\n \"def process(self, sess):\\n\\n sess.run(self.sync) # copy weights from shared to local\\n rollout = self.pull_batch_from_queue()\\n batch = process_rollout(rollout, gamma=0.99, lambda_=1.0)\\n\\n should_compute_summary = self.task == 0 and self.local_steps % 11 == 0\\n\\n if should_compute_summary:\\n fetches = [self.summary_op, self.train_op, self.global_step]\\n else:\\n fetches = [self.train_op, self.global_step]\\n\\n feed_dict = {\\n self.local_network.x: batch.si,\\n self.ac: batch.a,\\n self.adv: batch.adv,\\n self.r: batch.r,\\n self.local_network.state_in[0]: batch.features[0],\\n self.local_network.state_in[1]: batch.features[1],\\n }\\n\\n fetched = sess.run(fetches, feed_dict=feed_dict)\\n\\n if should_compute_summary:\\n self.summary_writer.add_summary(tf.Summary.FromString(fetched[0]), fetched[-1])\\n self.summary_writer.flush()\\n self.local_steps += 1\",\n \"def prepare_training_components(self):\\n # Instantiate model objects.\\n self.instantiate_model_objects()\\n\\n # Create checkpoint machinery to save/restore checkpoints.\\n self.create_checkpoint_machinery()\\n\\n # Create summary file writer.\\n self.summary_file_writer = tf.summary.create_file_writer(\\n logdir=os.path.join(self.params[\\\"output_dir\\\"], \\\"summaries\\\"),\\n name=\\\"summary_file_writer\\\"\\n )\",\n \"def sample_model(model, x, y, params_init, model_loss='multi_class_linear_output' ,num_samples=10, num_steps_per_sample=10, step_size=0.1, burn=0, inv_mass=None, jitter=None, normalizing_const=1., softabs_const=None, explicit_binding_const=100, fixed_point_threshold=1e-5, fixed_point_max_iterations=1000, jitter_max_tries=10, sampler=Sampler.HMC, integrator=Integrator.IMPLICIT, metric=Metric.HESSIAN, debug=False, tau_out=1.,tau_list=None, store_on_GPU = True, desired_accept_rate=0.8, verbose = False):\\n\\n device = params_init.device\\n params_shape_list = []\\n params_flattened_list = []\\n build_tau = False\\n if tau_list is None:\\n tau_list = []\\n build_tau = True\\n for weights in model.parameters():\\n params_shape_list.append(weights.shape)\\n params_flattened_list.append(weights.nelement())\\n if build_tau:\\n tau_list.append(torch.tensor(1.))\\n\\n log_prob_func = define_model_log_prob(model, model_loss, x, y, params_flattened_list, params_shape_list, tau_list, tau_out, normalizing_const=normalizing_const, device = device)\\n\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n\\n return sample(log_prob_func, params_init, num_samples=num_samples, num_steps_per_sample=num_steps_per_sample, step_size=step_size, burn=burn, jitter=jitter, inv_mass=inv_mass, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, fixed_point_threshold=fixed_point_threshold, fixed_point_max_iterations=fixed_point_max_iterations, jitter_max_tries=jitter_max_tries, sampler=sampler, integrator=integrator, metric=metric, debug=debug, desired_accept_rate=desired_accept_rate, store_on_GPU = store_on_GPU, verbose = verbose)\",\n \"def adjust_model_for_gpus(self) -> None:\\n if self._model is None:\\n raise ValueError(\\\"Model must be created before it can be adjusted.\\\")\\n\\n # Adjusting twice causes an error.\\n if self.is_model_adjusted:\\n logging.debug(\\\"model_and_info.is_model_adjusted is already True\\\")\\n\\n if self._optimizer:\\n raise ValueError(\\\"Create an optimizer only after creating and adjusting the model.\\\")\\n\\n self._model = ModelAndInfo._adjust_for_gpus(model=self._model,\\n config=self.config,\\n model_execution_mode=self.model_execution_mode)\\n\\n self.is_model_adjusted = True\\n logging.debug(\\\"model_and_info.is_model_adjusted set to True\\\")\",\n \"def compute_stats(self, epoch, loader, setname):\\n args = self.args\\n self.model.eval()\\n ndevbatches = len(self.dev_loader)\\n logging.info(f\\\"Evaluating {ndevbatches} batches ...\\\")\\n\\n recons, gts = defaultdict(list), defaultdict(list)\\n acquisition_machine_by_fname = dict()\\n with torch.no_grad():\\n for batch_idx, batch in enumerate(self.dev_loader):\\n progress = epoch + batch_idx/ndevbatches\\n logging_epoch = batch_idx % args.log_interval == 0\\n logging_epoch_info = batch_idx % (2 * args.log_interval) == 0\\n log = logging.info if logging_epoch_info else logging.debug\\n\\n self.start_of_test_batch_hook(progress, logging_epoch)\\n\\n batch = self.preprocess_data(batch)\\n output, target = self.predict(batch)\\n output = self.unnorm(output, batch)\\n target = self.unnorm(target, batch)\\n fname, slice = batch.fname, batch.slice\\n\\n for i in range(output.shape[0]):\\n slice_cpu = slice[i].item()\\n recons[fname[i]].append((slice_cpu, output[i].float().cpu().numpy()))\\n gts[fname[i]].append((slice_cpu, target[i].float().cpu().numpy()))\\n\\n acquisition_type = batch.attrs_dict['acquisition'][i]\\n machine_type = batch.attrs_dict['system'][i]\\n acquisition_machine_by_fname[fname[i]] = machine_type + '_' + acquisition_type\\n\\n if logging_epoch or batch_idx == ndevbatches-1:\\n gpu_memory_gb = torch.cuda.memory_allocated()/1000000000\\n host_memory_gb = utils.host_memory_usage_in_gb()\\n log(f\\\"Evaluated {batch_idx+1} of {ndevbatches} (GPU Mem: {gpu_memory_gb:2.3f}gb Host Mem: {gpu_memory_gb:2.3f}gb)\\\")\\n sys.stdout.flush()\\n\\n if self.args.debug_epoch_stats:\\n break\\n del output, target, batch\\n\\n logging.debug(f\\\"Finished evaluating\\\")\\n self.end_of_test_epoch_hook()\\n\\n recons = {\\n fname: np.stack([pred for _, pred in sorted(slice_preds)])\\n for fname, slice_preds in recons.items()\\n }\\n gts = {\\n fname: np.stack([pred for _, pred in sorted(slice_preds)])\\n for fname, slice_preds in gts.items()\\n }\\n\\n nmse, psnr, ssims = [], [], []\\n ssim_for_acquisition_machine = defaultdict(list)\\n recon_keys = list(recons.keys()).copy()\\n for fname in recon_keys:\\n pred_or, gt_or = recons[fname].squeeze(1), gts[fname].squeeze(1)\\n pred, gt = transforms.center_crop_to_smallest(pred_or, gt_or)\\n del pred_or, gt_or\\n\\n ssim = evaluate.ssim(gt, pred)\\n acquisition_machine = acquisition_machine_by_fname[fname]\\n ssim_for_acquisition_machine[acquisition_machine].append(ssim)\\n ssims.append(ssim)\\n nmse.append(evaluate.nmse(gt, pred))\\n psnr.append(evaluate.psnr(gt, pred))\\n del gt, pred\\n del recons[fname], gts[fname]\\n\\n if len(nmse) == 0:\\n nmse.append(0)\\n ssims.append(0)\\n psnr.append(0)\\n\\n min_vol_ssim = np.argmin(ssims)\\n min_vol = str(recon_keys[min_vol_ssim])\\n logging.info(f\\\"Min vol ssims: {min_vol}\\\")\\n sys.stdout.flush()\\n\\n del recons, gts\\n\\n acquisition_machine_losses = dict.fromkeys(self.dev_data.system_acquisitions, 0)\\n for key, value in ssim_for_acquisition_machine.items():\\n acquisition_machine_losses[key] = np.mean(value)\\n\\n losses = {'NMSE': np.mean(nmse),\\n 'PSNR': np.mean(psnr),\\n 'SSIM': np.mean(ssims),\\n 'SSIM_var': np.var(ssims),\\n 'SSIM_min': np.min(ssims),\\n **acquisition_machine_losses}\\n\\n return losses\",\n \"def create_models(self):\\r\\n self.all_ratings = AllRatingsWithCommon(\\r\\n experts=self.users,\\r\\n objects=self.videos,\\r\\n output_features=self.features,\\r\\n name=\\\"prod\\\",\\r\\n )\\r\\n\\r\\n print_memory(stage=\\\"DPLF:ratings_nodata_created\\\")\\r\\n\\r\\n # creating models\\r\\n self.user_to_model = {\\r\\n user: FeaturelessPreferenceLearningModel(\\r\\n expert=user, all_ratings=self.all_ratings\\r\\n )\\r\\n for user in self.users\\r\\n }\\r\\n\\r\\n print_memory(stage=\\\"DPLF:models_created\\\")\\r\\n\\r\\n # before creating the aggregator, filling models with data\\r\\n self.user_to_size = {\\r\\n user: self.fill_model_data(self.user_to_model[user], user)\\r\\n for user in tqdmem(self.users, desc=\\\"fill_data\\\")\\r\\n }\\r\\n\\r\\n # virtual 'common' data\\r\\n fplm_common = FeaturelessPreferenceLearningModel(\\r\\n expert=AllRatingsWithCommon.COMMON_EXPERT, all_ratings=self.all_ratings\\r\\n )\\r\\n fplm_common.on_dataset_end()\\r\\n\\r\\n print_memory(stage=\\\"DPLF:data_filled\\\")\\r\\n\\r\\n # resetting the model given the data\\r\\n self.all_ratings.reset_model()\\r\\n\\r\\n print_memory(stage=\\\"DPLF:model_reset_ok\\\")\\r\\n\\r\\n # aggregating models\\r\\n self.aggregator = FeaturelessMedianPreferenceAverageRegularizationAggregator(\\r\\n models=[self.user_to_model[u] for u in self.users]\\r\\n )\\r\\n self.aggregator.certification_status = self.user_certified\\r\\n\\r\\n print_memory(stage=\\\"DPLF:aggregator_created\\\")\",\n \"def process(self, sess):\\n\\n sess.run(self.sync) # copy weights from shared to local\\n rollout = next(self.rollout_provider)\\n batch = process_rollout(rollout, gamma=self.config.discount)\\n\\n should_compute_summary = (self.task == 0 \\n and self.local_steps % self.config.summary_every == 0)\\n\\n if should_compute_summary:\\n fetches = [self.summary_op, self.train_op, self.global_step]\\n else:\\n fetches = [self.train_op, self.global_step]\\n\\n feed_dict = {\\n self.local_network.x: batch.si,\\n self.r: batch.r,\\n self.w: batch.w,\\n self.local_network.state_in[0]: batch.features[0],\\n self.local_network.state_in[1]: batch.features[1],\\n }\\n\\n fetched = sess.run(fetches, feed_dict=feed_dict)\\n\\n if should_compute_summary:\\n self.summary_writer.add_summary(\\n tf.Summary.FromString(fetched[0]), fetched[-1])\\n self.summary_writer.flush()\\n self.local_steps += 1\",\n \"def run(self):\\n\\n self._logger.debug(\\\"Starting Dummy Model: modelID=%s;\\\" % (self._modelID))\\n\\n # =========================================================================\\n # Initialize periodic activities (e.g., for model result updates)\\n # =========================================================================\\n periodic = self._initPeriodicActivities()\\n\\n self._optimizedMetricLabel = self._optimizeKeyPattern\\n self._reportMetricLabels = [self._optimizeKeyPattern]\\n\\n # =========================================================================\\n # Create our top-level loop-control iterator\\n # =========================================================================\\n if self._iterations >= 0:\\n iterTracker = iter(xrange(self._iterations))\\n else:\\n iterTracker = iter(itertools.count())\\n\\n # =========================================================================\\n # This gets set in the unit tests. It tells the worker to sys exit\\n # the first N models. This is how we generate orphaned models\\n doSysExit = False\\n if self._sysExitModelRange is not None:\\n modelAndCounters = self._jobsDAO.modelsGetUpdateCounters(self._jobID)\\n modelIDs = [x[0] for x in modelAndCounters]\\n modelIDs.sort()\\n (beg,end) = self._sysExitModelRange\\n if self._modelID in modelIDs[int(beg):int(end)]:\\n doSysExit = True\\n\\n if self._delayModelRange is not None:\\n modelAndCounters = self._jobsDAO.modelsGetUpdateCounters(self._jobID)\\n modelIDs = [x[0] for x in modelAndCounters]\\n modelIDs.sort()\\n (beg,end) = self._delayModelRange\\n if self._modelID in modelIDs[int(beg):int(end)]:\\n time.sleep(10)\\n \\n # DEBUG!!!! infinite wait if we have 50 models\\n #if len(modelIDs) >= 50:\\n # jobCancel = self._jobsDAO.jobGetFields(self._jobID, ['cancel'])[0]\\n # while not jobCancel:\\n # time.sleep(1)\\n # jobCancel = self._jobsDAO.jobGetFields(self._jobID, ['cancel'])[0]\\n\\n if self._errModelRange is not None:\\n modelAndCounters = self._jobsDAO.modelsGetUpdateCounters(self._jobID)\\n modelIDs = [x[0] for x in modelAndCounters]\\n modelIDs.sort()\\n (beg,end) = self._errModelRange\\n if self._modelID in modelIDs[int(beg):int(end)]:\\n raise RuntimeError(\\\"Exiting with error due to errModelRange parameter\\\")\\n\\n # =========================================================================\\n # Delay, if necessary\\n if self._delay is not None:\\n time.sleep(self._delay)\\n\\n # =========================================================================\\n # Run it!\\n # =========================================================================\\n self._currentRecordIndex = 0\\n while True:\\n\\n # =========================================================================\\n # Check if the model should be stopped\\n # =========================================================================\\n\\n # If killed by a terminator, stop running\\n if self._isKilled:\\n break\\n\\n # If job stops or hypersearch ends, stop running\\n if self._isCanceled:\\n break\\n\\n # If model is mature, stop running ONLY IF we are not the best model\\n # for the job. Otherwise, keep running so we can keep returning\\n # predictions to the user\\n if self._isMature:\\n if not self._isBestModel:\\n self._cmpReason = self._jobsDAO.CMPL_REASON_STOPPED\\n break\\n else:\\n self._cmpReason = self._jobsDAO.CMPL_REASON_EOF\\n\\n # =========================================================================\\n # Get the the next record, and \\\"write it\\\"\\n # =========================================================================\\n try:\\n self._currentRecordIndex = next(iterTracker)\\n except StopIteration:\\n break\\n\\n # \\\"Write\\\" a dummy output value. This is used to test that the batched\\n # writing works properly\\n\\n self._writePrediction(ModelResult(None, None, None, None))\\n\\n periodic.tick()\\n\\n # =========================================================================\\n # Compute wait times. See if model should exit\\n # =========================================================================\\n\\n if self.__shouldSysExit(self._currentRecordIndex):\\n sys.exit(1)\\n\\n # Simulate computation time\\n if self._busyWaitTime is not None:\\n time.sleep(self._busyWaitTime)\\n self.__computeWaitTime()\\n\\n # Asked to abort after so many iterations?\\n if doSysExit:\\n sys.exit(1)\\n\\n # Asked to raise a jobFailException?\\n if self._jobFailErr:\\n raise utils.JobFailException(\\\"E10000\\\",\\n \\\"dummyModel's jobFailErr was True.\\\")\\n\\n # =========================================================================\\n # Handle final operations\\n # =========================================================================\\n if self._doFinalize:\\n if not self._makeCheckpoint:\\n self._model = None\\n\\n # Delay finalization operation\\n if self._finalDelay is not None:\\n time.sleep(self._finalDelay)\\n\\n self._finalize()\\n\\n self._logger.info(\\\"Finished: modelID=%r \\\"% (self._modelID))\\n\\n return (self._cmpReason, None)\",\n \"def represent():\\n\\tmodel.eval()\\n\\twith torch.no_grad():\\n\\n\\t\\tall_data = []\\n\\t\\tall_targets = []\\n\\n\\t\\tfor batch_idx, (data, labels) in enumerate(nat_test_loader):\\n\\t\\t\\tall_data.append(data)\\n\\t\\t\\tall_targets.append(labels.float()+50) # +50 for nat data, for distinction between nat and syn\\n\\t\\tfor batch_idx, (data, labels) in enumerate(syn_test_loader):\\n\\t\\t\\tall_data.append(data)\\n\\t\\t\\tall_targets.append(labels.float())\\n\\n\\t\\tall_data = torch.cat(all_data, 0) # Merges the list of tensors\\n\\t\\tall_data = all_data.cuda()\\n\\t\\tall_targets = torch.cat(all_targets, 0)\\n\\n\\t\\trepresentation = model.representation(all_data)\\n\\t\\t\\n\\t\\ttorch.save(representation, directory + \\\"/representations/repr\\\" + str(epoch) + \\\".pt\\\")\\n\\t\\twith open(directory + \\\"/representations/tar\\\" + str(epoch) + \\\".log\\\", \\\"w\\\") as f:\\n\\t\\t\\tfor t in all_targets:\\n\\t\\t\\t\\tf.write(str(t.item()) + \\\"\\\\n\\\")\\n\\n\\t\\t# Optional: Plotting of the UMAP in each represent()\\n\\t\\t#sns.set(style='white', context='notebook', rc={'figure.figsize': (14, 10)})\\n\\t\\t#reducer = umap.UMAP()\\n\\t\\t#embedding = reducer.fit_transform(representation.cpu())\\n\\t\\t# flatui = [\\\"#ff0000\\\", \\\"#000000\\\", \\\"#001800\\\", \\\"#003000\\\", \\\"#004800\\\", \\\"#006000\\\", \\\"#007800\\\", \\\"#009000\\\", \\\"#00a800\\\", \\\"#00c000\\\", \\\"#00d800\\\"]\\n\\t\\t# plt.scatter(embedding[:, 0], embedding[:, 1], c=[sns.color_palette(flatui)[x] for x in all_targets.int()])\\n\\t\\t#plt.scatter(embedding[:, 0], embedding[:, 1], c=all_targets.cpu())\\n\\t\\t#plt.gca().set_aspect('equal', 'datalim')\\n\\t\\t#plt.title('UMAP projection of cell data', fontsize=24);\\n\\t\\t#plt.savefig(directory + \\\"/umap_\\\" + str(epoch) + \\\".png\\\")\\n\\t\\t#plt.clf()\",\n \"def train(model, train_sampler, train_loader, test_sampler, test_loader,\\n use_cuda, epochs, loss_func, optimizer_name, lr,\\n batch_log_interval, hvd, smlb_out):\\n console = smlb_out.log.console\\n device = smlb_out.log.device\\n\\n # training history (validation only)\\n with console.subproc('Creating training history'):\\n loss_val_hist = torch.zeros(epochs, dtype=torch.float32)\\n acc_val_hist = torch.zeros(epochs, dtype=torch.float32)\\n\\n # send to device\\n if use_cuda:\\n with console.subproc('Sending model and history to device'):\\n model.cuda()\\n loss_val_hist = loss_val_hist.cuda()\\n acc_val_hist = acc_val_hist.cuda()\\n\\n # loss\\n with console.subproc('Creating loss function'):\\n loss_func = eval(f'nn.{loss_func}()')\\n console.message(f'Loss function: {loss_func}')\\n\\n # optimizer\\n with console.subproc('Creating optimizer'):\\n console.message(f'Learning rate specified: {lr}')\\n console.message(f'Reduction operation: {\\\"hvd.Average\\\"}')\\n console.message(f'Learning rate will be scaled by a factor of '\\n f'{hvd.size()} (hvd.size())')\\n optimizer = eval(f'torch.optim.{optimizer_name}(model.parameters(), '\\n f'lr={lr * hvd.size()})')\\n console.message(f'Optimizer: {optimizer}')\\n # Horovod: wrap optimizer with DistributedOptimizer\\n optimizer = hvd.DistributedOptimizer(optimizer, op=hvd.Average)\\n\\n # Horovod: broadcast model and optimizer\\n with console.subproc('Broadcasting model and optimizer'):\\n hvd.broadcast_parameters(model.state_dict(), root_rank=0)\\n hvd.broadcast_optimizer_state(optimizer, root_rank=0)\\n\\n # ----------------------\\n # Epoch loop starts here\\n # ----------------------\\n console.begin('**** EPOCH LOOP ****')\\n device.begin('**** EPOCH LOOP ****')\\n for epoch in range(epochs):\\n # only log on device within epoch loop\\n device.begin(f'Epoch: {epoch}')\\n\\n # -------------------\\n # Training batch loop\\n # -------------------\\n device.begin('Training batch loop')\\n # stamp train epoch in system monitor\\n smlb_out.system.stamp_event(f'epoch {epoch}: train')\\n # enter train mode\\n model.train()\\n # Horovod: set epoch to sampler for shuffling\\n train_sampler.set_epoch(epoch)\\n # batch loop\\n for batch_idx, (batch_x, batch_y) in enumerate(train_loader):\\n if use_cuda:\\n batch_x, batch_y = batch_x.cuda(), batch_y.cuda()\\n # forward, loss, acc\\n pred_y = model(batch_x)\\n loss = loss_func(pred_y, batch_y)\\n # backward\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n if batch_idx % batch_log_interval == 0:\\n # accuracy on batch\\n with torch.no_grad():\\n acc = compute_acc(pred_y, batch_y)\\n # Horovod: use train_sampler to determine the number of\\n # samples in this worker's partition\\n device.message(\\n '[{:5d}/{:5d} ({:3.0f}%)] loss={:f}, acc={:f}, '\\n 'elapsed={:f} sec'.format(\\n batch_idx * len(batch_x), len(train_sampler),\\n 100 * batch_idx / len(train_loader), loss, acc,\\n device.elapsed_shallowest))\\n device.ended('Training batch loop')\\n\\n # ----------------------\\n # Validation on test set\\n # ----------------------\\n device.begin('Validating on test set')\\n # stamp validate epoch in system monitor\\n smlb_out.system.stamp_event(f'epoch {epoch}: validate')\\n # enter eval mode\\n model.eval()\\n # accumulate loss and acc\\n loss_val = torch.zeros((1,), dtype=torch.float32)\\n acc_val = torch.zeros((1,), dtype=torch.float32)\\n if use_cuda:\\n loss_val, acc_val = loss_val.cuda(), acc_val.cuda()\\n for batch_x, batch_y in test_loader:\\n if use_cuda:\\n batch_x, batch_y = batch_x.cuda(), batch_y.cuda()\\n # forward, loss, acc\\n with torch.no_grad():\\n pred_y = model(batch_x)\\n loss_val += loss_func(pred_y, batch_y)\\n acc_val += compute_acc(pred_y, batch_y) * len(pred_y)\\n if use_cuda:\\n loss_val, acc_val = loss_val.cpu(), acc_val.cpu()\\n loss_val /= len(test_sampler)\\n acc_val /= len(test_sampler)\\n # average metrics across ranks and save to history\\n with device.subproc('Averaging metrics across ranks (allreduce)'):\\n loss_val_hist[epoch] = metric_average(loss_val, 'avg_loss', hvd)\\n acc_val_hist[epoch] = metric_average(acc_val, 'avg_accuracy', hvd)\\n # log device-wise and average metrics\\n device.message('Metrics on rank: loss_val={:f}, acc_val={:f}'\\n .format(loss_val.item(), acc_val.item()))\\n device.message('Average metrics: loss_val={:f}, acc_val={:f}'\\n .format(loss_val_hist[epoch], acc_val_hist[epoch]))\\n device.ended('Validating on test set')\\n\\n # only show average on console\\n console.message(f'Epoch {epoch:2d}: '\\n f'loss_val={loss_val_hist[epoch]:f}, '\\n f'acc_val={acc_val_hist[epoch]:f}, '\\n f'elapsed={device.elapsed_shallowest:f} sec')\\n device.ended(f'Epoch: {epoch}')\\n device.ended('**** EPOCH LOOP ****')\\n console.ended('**** EPOCH LOOP ****')\\n\\n # send model and data back to CPU\\n if use_cuda:\\n with console.subproc('Sending model and history back to cpu'):\\n model.cpu()\\n loss_val_hist = loss_val_hist.cpu()\\n acc_val_hist = acc_val_hist.cpu()\\n\\n # return history\\n return {'loss_val': loss_val_hist.numpy().tolist(),\\n 'acc_val_hist': acc_val_hist.numpy().tolist()}\",\n \"def load(self):\\n utils.get_previous_weights_from_gdrive(self.config.model_folder)\\n last_used_model = utils.get_latest_model_name(self.config.model_folder)\\n self.model = load_model(last_used_model)\\n self.model.summary()\",\n \"def single_gpu_online_evaluation(\\n model: Module,\\n data_loader: DataLoader,\\n metric: Union[str, Sequence[str]] = 'EPE') -> Dict[str, np.ndarray]:\\n\\n model.eval()\\n metrics = metric if isinstance(metric, (type, list)) else [metric]\\n result_metrics = defaultdict(list)\\n\\n prog_bar = mmcv.ProgressBar(len(data_loader))\\n for data in data_loader:\\n with torch.no_grad():\\n batch_results = model(test_mode=True, **data)\\n img_metas = data['img_metas'].data[0]\\n batch_flow = []\\n batch_flow_gt = []\\n batch_valid = []\\n # a batch of result and a batch of img_metas\\n for i in range(len(batch_results)):\\n result = batch_results[i]\\n img_meta = img_metas[i]\\n\\n # result.keys() is 'flow' or ['flow_fw','flow_bw']\\n # img_meta.keys() is 'flow_gt' or ['flow_fw_gt','flow_bw_gt']\\n for k in result.keys():\\n\\n if img_meta.get(k + '_gt', None) is None:\\n # img_meta does not have flow_bw_gt, so just check\\n # the forward predicted.\\n if k == 'flow_bw':\\n continue\\n elif k == 'flow_fw':\\n batch_flow_gt.append(img_meta['flow_gt'])\\n else:\\n batch_flow_gt.append(img_meta[k + '_gt'])\\n\\n batch_flow.append(result[k])\\n batch_valid.append(\\n img_meta.get('valid', np.ones_like(result[k][..., 0])))\\n\\n batch_results_metrics = eval_metrics(batch_flow, batch_flow_gt,\\n batch_valid, metrics)\\n for i_metric in metrics:\\n result_metrics[i_metric].append(\\n batch_results_metrics[i_metric])\\n\\n prog_bar.update()\\n\\n for i_metric in metrics:\\n if result_metrics.get(i_metric) is None:\\n raise KeyError(f'Model cannot compute {i_metric}')\\n result_metrics[i_metric] = np.array(result_metrics[i_metric]).mean()\\n\\n return result_metrics\",\n \"def train(model_name, batch_size, steps_per_epoch, epochs, validation_steps, \\n model_file=None, save_path=None):\\n \\n print(\\\"- Loading configuration...\\\")\\n if model_name in models_default_params:\\n default_params = models_default_params[model_name]\\n else:\\n print(\\\"Error: the model '{}' has not been implemented\\\".format(model_name))\\n return\\n custom_objects = default_params['custom_objects']\\n patch_size = default_params['patch_size']\\n if save_path is None:\\n save_path = default_params['default_path']\\n if os.path.isfile(save_path):\\n print(\\\"Warning: {} is an existing file and will be overwritten.\\\".format(save_path))\\n print(\\\"- Configuration loaded.\\\")\\n \\n print(\\\"- Loading datasets...\\\")\\n train_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Training/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Training/Labels/\\\",\\n patch_size = patch_size)\\n val_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Validation/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Validation/Labels/\\\",\\n patch_size = patch_size)\\n print(\\\"- Data loaded.\\\")\\n \\n print(\\\"- Initialising model...\\\")\\n if(model_file is not None): # Further train existing model\\n model = keras.models.load_model(model_file, custom_objects=custom_objects)\\n else: # Create new model\\n if model_name == 'fcn':\\n model = fcn.make_fcn_resnet((patch_size, patch_size, channels), nb_labels, \\n use_pretraining=False, freeze_base=False)\\n elif model_name == 'pspnet':\\n model = pspnet.build_pspnet(nb_classes=nb_labels, resnet_layers=50,\\n input_shape=patch_size)\\n elif model_name == 'mobilenetv2':\\n model = mobilenetv2.MobileNetv2((patch_size, patch_size, channels), nb_labels) \\n\\n model.compile(\\n optimizer = optimizers.Adam(lr = 0.00001),\\n loss = losses.categorical_crossentropy,\\n metrics = [metrics.categorical_accuracy]) \\n model.summary() \\n print(\\\"- Model initialised.\\\")\\n \\n tensorboard = callbacks.TensorBoard(log_dir='./logs')\\n csv_logger = callbacks.CSVLogger('logs/training.csv')\\n checkpoint = callbacks.ModelCheckpoint(filepath=checkpoint_path,\\n save_weights_only=True,\\n save_best_only=True)\\n \\n print(\\\"- Starting training.\\\")\\n model.fit_generator(\\n generator=train_gen,\\n steps_per_epoch=steps_per_epoch,\\n epochs=epochs,\\n validation_data=val_gen,\\n validation_steps=validation_steps,\\n # callbacks=[checkpoint, csv_logger]\\n )\\n print(\\\"- Training complete.\\\")\\n \\n model.save(save_path)\\n print(\\\"- Model saved to {}\\\".format(save_path))\",\n \"def continueTraining(self,model): \\n self.setOldModel(model)\\n self.model.compile(optimizer = self.optimizer,\\n loss=self.loss_function,\\n metrics=self.metrics)\\n\\n self.setGenerators()\\n self.buildCallbacks()\\n self.printParameters()\\n\\n # fit model to data\\n _ = self.model.fit_generator(\\n generator = self.trainGen,\\n validation_data = self.validateGen,\\n steps_per_epoch = self.steps_per_epoch,\\n validation_steps = self.validation_steps,\\n epochs = self.epochs,\\n use_multiprocessing = True,\\n callbacks = self.callbacks)\",\n \"def run():\\n # get arguments\\n args = parse_args()\\n assert args.batch_size % args.gpu_num == 0\\n assert args.gru_hidden_size % 2 == 0\\n\\n # create a logger\\n logger = logging.getLogger(\\\"GACM\\\")\\n logger.setLevel(logging.INFO)\\n formatter = logging.Formatter('%(asctime)s - %(name)s - %(message)s')\\n check_path(args.save_dir)\\n check_path(args.load_dir)\\n check_path(args.result_dir)\\n check_path(args.summary_dir)\\n if args.log_dir:\\n check_path(args.log_dir)\\n file_handler = logging.FileHandler(args.log_dir + time.strftime('%Y-%m-%d-%H:%M:%S',time.localtime(time.time())) + '.txt')\\n file_handler.setLevel(logging.INFO)\\n file_handler.setFormatter(formatter)\\n logger.addHandler(file_handler)\\n else:\\n console_handler = logging.StreamHandler()\\n console_handler.setLevel(logging.INFO)\\n console_handler.setFormatter(formatter)\\n logger.addHandler(console_handler)\\n logger.info('Running with args : {}'.format(args))\\n\\n logger.info('Checking the directories...')\\n for dir_path in [args.save_dir, args.result_dir, args.summary_dir]:\\n if not os.path.exists(dir_path):\\n os.makedirs(dir_path)\\n \\n global Dataset\\n global Agent\\n logger.info('Agent version: {}.0'.format(args.agent_version))\\n logger.info('Dataset version: {}.0'.format(args.dataset_version))\\n logger.info('Checking the directories...')\\n Dataset = importlib.import_module('dataset{}'.format(args.dataset_version)).Dataset\\n Agent = importlib.import_module('Agent{}'.format(args.agent_version)).Agent\\n \\n if args.pretrain:\\n pretrain(args)\\n if args.train:\\n train(args)\\n if args.test:\\n test(args)\\n if args.rank:\\n rank(args)\\n if args.generate_synthetic_dataset:\\n generate_synthetic_dataset(args)\\n logger.info('run done.')\",\n \"def build_graph(self):\\n tf.logging.info('Building graph...')\\n t0 = time.time()\\n\\n self._add_placeholders()\\n\\n with tf.device(\\\"/gpu:%d\\\"%(config.gpu_selection)):\\n self._add_seq2seq()\\n\\n self.global_step = tf.Variable(0, name='global_step', trainable=False)\\n\\n\\n if self._mode == 'train':\\n self._add_train_op()\\n\\n self._summaries = tf.summary.merge_all()\\n\\n t1 = time.time()\\n tf.logging.info('Time to build graph: %i seconds', t1 - t0)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78193945","0.70014805","0.6252593","0.6235304","0.61942273","0.6128506","0.608759","0.5960813","0.59513026","0.59509206","0.58809274","0.58801025","0.5874364","0.5837946","0.58353555","0.5803747","0.57844466","0.5753908","0.5749925","0.57394","0.57334524","0.5730291","0.5723675","0.5723551","0.5714144","0.5712949","0.5692779","0.56628966","0.5652885","0.5649871","0.56397444","0.56347793","0.5621697","0.56064576","0.56024784","0.5601831","0.5590464","0.55842376","0.55842376","0.5569094","0.55589193","0.55413705","0.5531317","0.5520086","0.55031145","0.550202","0.54930073","0.54895484","0.548377","0.54824877","0.5479255","0.54764867","0.54705536","0.54702747","0.5467068","0.54656595","0.54656595","0.54492855","0.5445617","0.54426473","0.54424196","0.54378104","0.5433539","0.54329574","0.54329574","0.54313636","0.54310393","0.54268855","0.54237044","0.54152143","0.54072475","0.54070765","0.54042625","0.5403478","0.5401277","0.5399984","0.53989136","0.53984237","0.53953457","0.53936166","0.53922623","0.5380648","0.53768325","0.5367875","0.53622437","0.5361536","0.5357702","0.53524727","0.53506273","0.53396887","0.5334884","0.5334789","0.53316855","0.53310376","0.5330445","0.532972","0.53284","0.5326326","0.53259104","0.5324142"],"string":"[\n \"0.78193945\",\n \"0.70014805\",\n \"0.6252593\",\n \"0.6235304\",\n \"0.61942273\",\n \"0.6128506\",\n \"0.608759\",\n \"0.5960813\",\n \"0.59513026\",\n \"0.59509206\",\n \"0.58809274\",\n \"0.58801025\",\n \"0.5874364\",\n \"0.5837946\",\n \"0.58353555\",\n \"0.5803747\",\n \"0.57844466\",\n \"0.5753908\",\n \"0.5749925\",\n \"0.57394\",\n \"0.57334524\",\n \"0.5730291\",\n \"0.5723675\",\n \"0.5723551\",\n \"0.5714144\",\n \"0.5712949\",\n \"0.5692779\",\n \"0.56628966\",\n \"0.5652885\",\n \"0.5649871\",\n \"0.56397444\",\n \"0.56347793\",\n \"0.5621697\",\n \"0.56064576\",\n \"0.56024784\",\n \"0.5601831\",\n \"0.5590464\",\n \"0.55842376\",\n \"0.55842376\",\n \"0.5569094\",\n \"0.55589193\",\n \"0.55413705\",\n \"0.5531317\",\n \"0.5520086\",\n \"0.55031145\",\n \"0.550202\",\n \"0.54930073\",\n \"0.54895484\",\n \"0.548377\",\n \"0.54824877\",\n \"0.5479255\",\n \"0.54764867\",\n \"0.54705536\",\n \"0.54702747\",\n \"0.5467068\",\n \"0.54656595\",\n \"0.54656595\",\n \"0.54492855\",\n \"0.5445617\",\n \"0.54426473\",\n \"0.54424196\",\n \"0.54378104\",\n \"0.5433539\",\n \"0.54329574\",\n \"0.54329574\",\n \"0.54313636\",\n \"0.54310393\",\n \"0.54268855\",\n \"0.54237044\",\n \"0.54152143\",\n \"0.54072475\",\n \"0.54070765\",\n \"0.54042625\",\n \"0.5403478\",\n \"0.5401277\",\n \"0.5399984\",\n \"0.53989136\",\n \"0.53984237\",\n \"0.53953457\",\n \"0.53936166\",\n \"0.53922623\",\n \"0.5380648\",\n \"0.53768325\",\n \"0.5367875\",\n \"0.53622437\",\n \"0.5361536\",\n \"0.5357702\",\n \"0.53524727\",\n \"0.53506273\",\n \"0.53396887\",\n \"0.5334884\",\n \"0.5334789\",\n \"0.53316855\",\n \"0.53310376\",\n \"0.5330445\",\n \"0.532972\",\n \"0.53284\",\n \"0.5326326\",\n \"0.53259104\",\n \"0.5324142\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5817216"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":4477,"cells":{"query":{"kind":"string","value":"Creates a model as per the config, and loads the parameters from the given checkpoint path. Also updates the checkpoint_epoch."},"document":{"kind":"string","value":"def try_create_mean_teacher_model_and_load_from_checkpoint(self) -> bool:\n self.create_mean_teacher_model()\n if self.checkpoint_path:\n # Load the stored model. If there is no checkpoint present, return immediately.\n return self.try_load_checkpoint_for_mean_teacher_model()\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_checkpoint(model_config, path):\n model = models.VisionTransformer(num_classes=1, **model_config)\n variables = model.init(\n jax.random.PRNGKey(0),\n jnp.ones([1, 16, 16, 3], jnp.float32),\n train=False,\n )\n _save(variables['params'], path)","def load_model(self, checkpoint):\n print(f'Load parameters from {checkpoint}')\n epoch = re.match(r\"[0-9]*\", os.path.basename(checkpoint)).group(0)\n self.epoch_i = int(epoch)\n self.model.load_state_dict(torch.load(checkpoint))","def load(self, model_path):\n # TODO: include new params based on ConfigEnum\n checkpoint = torch.load(model_path)\n\n self.image_size = checkpoint['image_size']\n self.device = checkpoint['device']\n self.fp16 = checkpoint['fp16']\n self.accumulate_grad_steps = checkpoint['accumulate_grad_steps']\n self.experiment_id = checkpoint['experiment_id']\n self.experiment_tag = checkpoint['experiment_tag']\n self.seed = checkpoint['seed']\n self.train_batch_size = checkpoint['train_batch_size']\n self.valid_batch_size = checkpoint['valid_batch_size']\n self.test_batch_size = checkpoint['test_batch_size']\n self.dataloader_num_workers = checkpoint['dataloader_num_workers']\n self.train_dataloader_shuffle = checkpoint['train_dataloader_shuffle']\n self.optimizer_type = checkpoint['optimizer_type']\n self.optimizer_params = checkpoint['optimizer_params']\n self.scheduler_type = checkpoint['scheduler_type']\n self.scheduler_params = checkpoint['scheduler_params']\n self.step_scheduler_after = checkpoint['step_scheduler_after']\n self.step_scheduler_metric = checkpoint['step_scheduler_metric']\n self.compute_train_loss_after = checkpoint['compute_train_loss_after']\n self.compute_train_metric_after = checkpoint['compute_train_metric_after']\n self.compute_valid_loss_after = checkpoint['compute_valid_loss_after']\n self.compute_valid_metric_after = checkpoint['compute_valid_metric_after']\n self.training_stopping_criteria = checkpoint['training_stopping_criteria']\n self.stopping_criteria_params = checkpoint['stopping_criteria_params']\n self.max_epoch = checkpoint['max_epoch']\n self.train_on_all_data = checkpoint['train_on_all_data']\n self.validate_after = checkpoint['validate_after']\n self.validation_steps = checkpoint['validation_steps']\n self.run_lr_range_test= checkpoint['run_lr_range_test']\n self.sleep_in_epochs = checkpoint['sleep_in_epochs']\n self.sleep_time = checkpoint['sleep_time']\n self.checkpoint_epochs = checkpoint['checkpoint_epochs']\n\n self._best_score = checkpoint['_best_score']\n self._current_score = checkpoint['_current_score']\n self._counter = checkpoint['_counter']\n self.metrics = checkpoint['metrics']\n self.current_epoch = checkpoint['current_epoch']\n self.current_train_batch = checkpoint['current_train_batch']\n self.current_valid_batch = checkpoint['current_valid_batch']\n self.num_train_samples = checkpoint['num_train_samples']\n self.num_train_iterations = checkpoint['num_train_iterations']\n self.checkpoint_snapshot = checkpoint['checkpoint_snapshot'] \n\n # initialize optimizer, scheduler, and gradient scaler\n self.configure_optimizers()\n self.configure_schedulers()\n \n if self.fp16:\n self.scaler = torch.cuda.amp.GradScaler()\n\n if self.model:\n self.model.load_state_dict(checkpoint['state_dict'])\n self.model.to(self.device)\n\n if self.optimizer:\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n if self.scheduler:\n self.scheduler.load_state_dict(checkpoint['scheduler'])\n\n #if self.scaler:\n # self.scaler.load_state_dict(checkpoint['scaler'])","def init_model(config, program, exe):\n checkpoints = config['Global'].get('checkpoints')\n if checkpoints:\n if os.path.exists(checkpoints + '.pdparams'):\n path = checkpoints\n fluid.load(program, path, exe)\n logger.info(\"Finish initing model from {}\".format(path))\n else:\n raise ValueError(\"Model checkpoints {} does not exists,\"\n \"check if you lost the file prefix.\".format(\n checkpoints + '.pdparams'))\n else:\n pretrain_weights = config['Global'].get('pretrain_weights')\n if pretrain_weights:\n path = pretrain_weights\n load_params(exe, program, path)\n logger.info(\"Finish initing model from {}\".format(path))","def save_checkpoint(self, model_path=None):\n # TODO: include new params based on ConfigEnum\n if not os.path.isdir(path_checkpoints_dir):\n os.mkdir(path_checkpoints_dir)\n if model_path is None:\n model_path = os.path.join(path_checkpoints_dir, f\"{self.experiment_id}.pth\")\n print(f\"saved the model at {model_path}\") \n model_state_dict = self.model.state_dict()\n if self.optimizer is not None:\n opt_state_dict = self.optimizer.state_dict()\n else:\n opt_state_dict = None\n if self.scheduler is not None:\n sch_state_dict = self.scheduler.state_dict()\n else:\n sch_state_dict = None\n \n if self.scaler is not None:\n amp_grad_scaler = self.scaler.state_dict()\n else:\n amp_grad_scaler = None\n\n model_dict = {}\n model_dict[\"state_dict\"] = model_state_dict\n model_dict[\"optimizer\"] = opt_state_dict\n model_dict[\"scheduler\"] = sch_state_dict\n model_dict['scaler'] = amp_grad_scaler\n model_dict['image_size'] = self.image_size\n model_dict['device'] = self.device\n model_dict['fp16'] = self.fp16\n model_dict['accumulate_grad_steps'] = self.accumulate_grad_steps\n\n model_dict['experiment_id'] = self.experiment_id\n model_dict['experiment_tag'] = self.experiment_tag\n\n model_dict['seed'] = self.seed\n\n model_dict['train_batch_size'] = self.train_batch_size\n model_dict['valid_batch_size'] = self.valid_batch_size\n model_dict['test_batch_size'] = self.test_batch_size\n model_dict['dataloader_num_workers'] = self.dataloader_num_workers\n model_dict['train_dataloader_shuffle'] = self.train_dataloader_shuffle\n\n model_dict['optimizer_type'] = self.optimizer_type\n model_dict['optimizer_params'] = self.optimizer_params\n\n model_dict['scheduler_type'] = self.scheduler_type\n model_dict['scheduler_params'] = self.scheduler_params\n model_dict['step_scheduler_after'] = self.step_scheduler_after\n model_dict['step_scheduler_metric'] = self.step_scheduler_metric\n\n model_dict['compute_train_loss_after'] = self.compute_train_loss_after\n model_dict['compute_train_metric_after'] = self.compute_train_metric_after\n model_dict['compute_valid_loss_after'] = self.compute_valid_loss_after\n model_dict['compute_valid_metric_after'] = self.compute_valid_metric_after\n\n model_dict['training_stopping_criteria'] = self.training_stopping_criteria\n model_dict['stopping_criteria_params'] = self.stopping_criteria_params\n model_dict['max_epoch'] = self.max_epoch\n model_dict['train_on_all_data'] = self.train_on_all_data\n model_dict['validate_after'] = self.validate_after\n model_dict['validation_steps'] = self.validation_steps\n model_dict['run_lr_range_test'] = self.run_lr_range_test\n model_dict['sleep_in_epochs'] = self.sleep_in_epochs\n model_dict['sleep_time'] = self.sleep_time\n model_dict['checkpoint_epochs'] = self.checkpoint_epochs\n\n model_dict['_best_score'] = self._best_score\n model_dict['_current_score'] = self._current_score\n model_dict['_counter'] = self._counter\n\n model_dict['metrics'] = self.metrics\n model_dict['current_epoch'] = self.current_epoch\n model_dict['current_train_batch'] = self.current_train_batch\n model_dict['current_valid_batch'] = self.current_valid_batch\n\n model_dict['num_train_samples'] = self.num_train_samples\n model_dict['num_train_iterations'] = self.num_train_iterations\n model_dict['checkpoint_snapshot'] = self.checkpoint_snapshot \n torch.save(model_dict, model_path)","def initialize_model(session, model, train_dir, expect_exists):\n print \"Looking for model at %s...\" % train_dir\n ckpt = tf.train.get_checkpoint_state(train_dir)\n v2_path = ckpt.model_checkpoint_path + \".index\" if ckpt else \"\"\n if ckpt and (tf.gfile.Exists(ckpt.model_checkpoint_path) or tf.gfile.Exists(v2_path)):\n print \"Reading model parameters from %s\" % ckpt.model_checkpoint_path\n model.saver.restore(session, ckpt.model_checkpoint_path)\n else:\n if expect_exists:\n raise Exception(\"There is no saved checkpoint at %s\" % train_dir)\n else:\n print \"There is no saved checkpoint at %s. Creating model with fresh parameters.\" % train_dir\n session.run(tf.global_variables_initializer())\n print 'Num params: %d' % sum(v.get_shape().num_elements() for v in tf.trainable_variables())","def initialize_model(session, model, train_dir, expect_exists):\n print \"Looking for model at %s...\" % train_dir\n ckpt = tf.train.get_checkpoint_state(train_dir)\n v2_path = ckpt.model_checkpoint_path + \".index\" if ckpt else \"\"\n if ckpt and (tf.gfile.Exists(ckpt.model_checkpoint_path) or tf.gfile.Exists(v2_path)):\n print \"Reading model parameters from %s\" % ckpt.model_checkpoint_path\n model.saver.restore(session, ckpt.model_checkpoint_path)\n else:\n if expect_exists:\n raise Exception(\"There is no saved checkpoint at %s\" % train_dir)\n else:\n print \"There is no saved checkpoint at %s. Creating model with fresh parameters.\" % train_dir\n session.run(tf.global_variables_initializer())\n print 'Num params: %d' % sum(v.get_shape().num_elements() for v in tf.trainable_variables())","def load_model(model, checkpoint_path: str): \r\n checkpoint = torch.load(checkpoint_path)\r\n model.load_state_dict(checkpoint['model'])\r\n epoch = checkpoint['epoch']\r\n print('Loaded model from {}, epoch {}'.format(checkpoint_path, epoch))","def load_model(self, ckpt_fn):\n checkpoint = torch.load(ckpt_fn)\n self.net_.load_state_dict(checkpoint[\"model\"])\n self.optimizer_.load_state_dict(checkpoint[\"optimizer\"])\n self.epoch_ = checkpoint[\"epoch\"]\n self.global_step_ = checkpoint[\"global_step\"]\n self.model_samples_ = deque(checkpoint[\"model_samples\"])\n self.sampler.load_state_dict(checkpoint[\"sampler_state\"])\n self.ais_loss.load_state_dict(checkpoint[\"ais_state\"])\n self.replay_prob = checkpoint[\"replay_prob\"]\n self.max_replay = checkpoint[\"max_replay\"]","def create_or_load_model(model, model_dir, session, name):\n latest_ckpt = tf.train.latest_checkpoint(model_dir)\n if latest_ckpt:\n start_time = time.time()\n # It only takes a few seconds to initialize all variables.\n session.run(tf.global_variables_initializer())\n logging.info(\n \"Initialize %s model with fresh parameters before loading variables \"\n \"from the checkpoint, time %.2fs\", name,\n time.time() - start_time)\n model = load_model(model, latest_ckpt, session, name)\n else:\n start_time = time.time()\n session.run(tf.global_variables_initializer())\n session.run(tf.tables_initializer())\n utils.print_out(\" created %s model with fresh parameters, time %.2fs\" %\n (name, time.time() - start_time))\n\n global_step = model.global_step.eval(session=session)\n return model, global_step","def load_checkpoint(path):\n\n # Get the model name\n model_name = path.split('-')[0]\n assert (model_name in ['vgg16', 'resnet50'\n ]), \"Path must have the correct model name\"\n\n # Load in checkpoint\n checkpoint = torch.load(path)\n\n if model_name == 'vgg16':\n model = models.vgg16(pretrained=True)\n # Make sure to set parameters as not trainable\n for param in model.parameters():\n param.requires_grad = False\n model.classifier = checkpoint['classifier']\n\n elif model_name == 'resnet50':\n model = models.resnet50(pretrained=True)\n # Make sure to set parameters as not trainable\n for param in model.parameters():\n param.requires_grad = False\n model.fc = checkpoint['fc']\n\n # Load in the state dict\n model.load_state_dict(checkpoint['state_dict'])\n\n total_params = sum(p.numel() for p in model.parameters())\n print(f'{total_params:,} total parameters.')\n total_trainable_params = sum(\n p.numel() for p in model.parameters() if p.requires_grad)\n print(f'{total_trainable_params:,} total gradient parameters.')\n\n # Move to gpu\n if multi_gpu:\n model = nn.DataParallel(model)\n\n if train_on_gpu:\n model = model.to('cuda')\n\n # Model basics\n model.class_to_idx = checkpoint['class_to_idx']\n model.idx_to_class = checkpoint['idx_to_class']\n model.epochs = checkpoint['epochs']\n\n # Optimizer\n optimizer = checkpoint['optimizer']\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n\n return model, optimizer","def load(cls, model_path: str, sample_shape: tuple = None,\n checkpoint: str = None, **kwargs):","def load_checkpoint(tag, params, model):\r\n file_name = os.path.join(\"saved_models\", params.path, tag + \".pt\")\r\n logger.info(\"Load checkpoint from %s\" % file_name)\r\n if os.path.exists(file_name):\r\n checkpoint = torch.load(file_name, map_location='cpu')\r\n params.training_id = checkpoint['training_id']\r\n logger.info(checkpoint['training_id'])\r\n model.global_step = checkpoint['global_step']\r\n model.load_state_dict(checkpoint['model'])\r\n for i, optimizer in enumerate(model.optimizers):\r\n optimizer.load_state_dict(checkpoint['optimizers'][i])\r\n else:\r\n raise Exception(\"Checkpoint not found.\")","def load_checkpoint(filepath):\n checkpoint = torch.load(filepath)\n \n arch = checkpoint['arch']\n if arch == 'vgg':\n model = models.vgg16(pretrained=True)\n elif arch == 'densenet':\n model = models.densenet121(pretrained=True) \n \n model.class_to_idx = checkpoint['class_to_idx']\n model.classifier = checkpoint['classifier']\n model.classifier.load_sate_dict = checkpoint['classifier_state_dict']\n model.optimizer = checkpoint['optimizer_state_dict']\n model.input_size = checkpoint['input_size']\n model.output_size = checkpoint['output_size']\n \n return model","def createModel(config_path, checkpoint_path, graph_path):\n\n global build_graph, prev_classes\n\n trt_graph = None\n input_names = None\n \n if build_graph:\n frozen_graph, input_names, output_names = build_detection_graph(\n config=config_path,\n checkpoint=checkpoint_path\n )\n \n trt_graph = trt.create_inference_graph(\n input_graph_def=frozen_graph,\n outputs=output_names,\n max_batch_size=1,\n max_workspace_size_bytes=1 << 25,\n precision_mode='FP16',\n minimum_segment_size=50\n )\n\n with open(graph_path, 'wb') as f:\n f.write(trt_graph.SerializeToString())\n\n with open('config.txt', 'r+') as json_file: \n data = json.load(json_file)\n data['model'] = []\n data['model'] = [{'input_names': input_names}]\n json_file.seek(0)\n json_file.truncate()\n json.dump(data, json_file)\n\n else:\n with open(graph_path, 'rb') as f:\n trt_graph = tf.GraphDef()\n trt_graph.ParseFromString(f.read())\n with open('config.txt') as json_file: \n data = json.load(json_file)\n input_names = data['model'][0]['input_names']\n\n return Model(trt_graph, input_names)","def maybe_load_model(name, split_num, checkpoint_dir, resume_from_epoch,\n batch_norm, l1_factor, l2_factor, optimizer):\n basename = get_basename(name, split_num)\n model_filename_fmt = get_model_filename_fmt(basename)\n model_filename = model_filename_fmt.format(epoch=resume_from_epoch)\n\n checkpoint_path = os.path.join(checkpoint_dir, model_filename)\n\n if resume_from_epoch > 0 and os.path.isfile(checkpoint_path):\n\n click.secho(f\"Found model checkpoint '{checkpoint_path}'. \"\n f\"Resuming from epoch {resume_from_epoch}.\", fg='green')\n\n model = load_model(checkpoint_path)\n\n initial_epoch = resume_from_epoch\n\n else:\n\n click.secho(f\"Could not load model checkpoint '{checkpoint_path}' \"\n \"or `resume_from_epoch == 0`. Building new model.\",\n fg='yellow')\n\n model = build_model(output_dim=1, batch_norm=batch_norm,\n kernel_regularizer=l1_l2(l1_factor, l2_factor))\n # optimizer = Adam(beta_1=0.5)\n model.compile(loss='binary_crossentropy', optimizer=optimizer,\n metrics=['accuracy'])\n\n initial_epoch = 0\n\n return model, initial_epoch","def load_model(self, checkpoint_path):\n model = self.model_definition()\n model.load_weights(checkpoint_path)\n return model","def restore_checkpoint(model, checkpoint_dir, cuda=False, force=False, pretrain=False):\n try:\n cp_files = [\n file_\n for file_ in os.listdir(checkpoint_dir)\n if file_.startswith(\"epoch=\") and file_.endswith(\".checkpoint.pth.tar\")\n ]\n except FileNotFoundError:\n cp_files = None\n os.makedirs(checkpoint_dir)\n if not cp_files:\n print(\"No saved model parameters found\")\n if force:\n raise Exception(\"Checkpoint not found\")\n else:\n return model, 0, []\n\n # Find latest epoch\n for i in itertools.count(1):\n if \"epoch={}.checkpoint.pth.tar\".format(i) in cp_files:\n epoch = i\n else:\n break\n\n if not force:\n print(\n \"Which epoch to load from? Choose in range [0, {}].\".format(epoch),\n \"Enter 0 to train from scratch.\",\n )\n print(\">> \", end=\"\")\n inp_epoch = int(input())\n if inp_epoch not in range(epoch + 1):\n raise Exception(\"Invalid epoch number\")\n if inp_epoch == 0:\n print(\"Checkpoint not loaded\")\n clear_checkpoint(checkpoint_dir)\n return model, 0, []\n else:\n print(\"Which epoch to load from? Choose in range [1, {}].\".format(epoch))\n inp_epoch = int(input())\n if inp_epoch not in range(1, epoch + 1):\n raise Exception(\"Invalid epoch number\")\n\n filename = os.path.join(\n checkpoint_dir, \"epoch={}.checkpoint.pth.tar\".format(inp_epoch)\n )\n\n print(\"Loading from checkpoint {}?\".format(filename))\n\n if cuda:\n checkpoint = torch.load(filename)\n else:\n # Load GPU model on CPU\n checkpoint = torch.load(filename, map_location=lambda storage, loc: storage)\n\n try:\n start_epoch = checkpoint[\"epoch\"]\n stats = checkpoint[\"stats\"]\n if pretrain:\n model.load_state_dict(checkpoint[\"state_dict\"], strict=False)\n else:\n model.load_state_dict(checkpoint[\"state_dict\"])\n print(\n \"=> Successfully restored checkpoint (trained for {} epochs)\".format(\n checkpoint[\"epoch\"]\n )\n )\n except:\n print(\"=> Checkpoint not successfully restored\")\n raise\n\n return model, inp_epoch, stats","def load_checkpoint(self):\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\n try:\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\n ckpt = torch.load(self.params.resume_from)\n self.epoch = ckpt['epoch']\n try:\n self.train_loss = ckpt['train_loss']\n self.val_loss = ckpt['val_loss']\n except:\n self.train_loss = []\n self.val_loss = []\n self.network.load_state_dict(ckpt['state_dict'])\n self.opt.load_state_dict(ckpt['optimizer'])\n LOG('Checkpoint Loaded!')\n LOG('Current Epoch: %d' % self.epoch)\n self.ckpt_flag = True\n except:\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\n else:\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')","def load_model_from_checkpoint(self, path: str):\n ckpt = torch.load(path, map_location='cpu')\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\n self.net_q.head.load_state_dict(ckpt['head'])\n self.net_ps.load_state_dict(ckpt['net_ps'])\n self.net_k.load_state_dict(ckpt['net_k'])\n self.queue.load_state_dict(ckpt['queue'])\n self.optimizer.load_state_dict(ckpt['optimizer'])\n if 'scheduler' in ckpt:\n self.scheduler.load_stae_dict(ckpt['scheduler'])\n self.move_optimizer_states(self.optimizer, self.local_rank)","def load_checkpoint(self, label):\n model_dir = os.path.join(\n config.results_dir, config.experiment_name, 'checkpoints')\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\n\n print(\"Loading model from {}\".format(model_file))\n model_dict = torch.load(model_file)\n\n self.use_cuda = model_dict['use_cuda']\n if self.use_cuda:\n self.net.cuda()\n\n self.net.load_state_dict(model_dict['net_state_dict'])","def load(cls, path):\n print(f'load checkpoint from {path}')\n if torch.cuda.is_available():\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\n else:\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\n \n # model.flatten_parameters() # make RNN parameters contiguous\n optimizer = resume_checkpoint['optimizer']\n return Checkpoint(\n model=model, \n optimizer=optimizer,\n epoch=resume_checkpoint['epoch'],\n path=path\n )","def load_model(path):\n if os.path.isfile(path):\n print(\"=> loading checkpoint '{}'\".format(path))\n checkpoint = torch.load(path)\n\n # # size of the top layer\n # N = checkpoint['state_dict']['top_layer.bias'].size()\n #\n # # build skeleton of the model\n # sob = 'sobel.0.weight' in checkpoint['state_dict'].keys()\n # model = models.__dict__[checkpoint['arch']](sobel=sob, out=int(N[0]))\n #\n # # deal with a dataparallel table\n # def rename_key(key):\n # if not 'module' in key:\n # return key\n # return ''.join(key.split('.module'))\n #\n # checkpoint['state_dict'] = {rename_key(key): val\n # for key, val\n # in checkpoint['state_dict'].items()}\n #\n # # load weights\n # model.load_state_dict(checkpoint['state_dict'])\n # print(\"Loaded\")\n # else:\n # model = None\n # print(\"=> no checkpoint found at '{}'\".format(path))\n\n # net = models.__dict__['ResNet18'](low_dim=128)\n # net = models.__dict__['resnet18'](low_dim=128)\n\n net = models.__dict__['alexnet'](out=128)\n # net = models.__dict__['Alexnet_C'](out=args.low_dim)\n\n net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))\n net.load_state_dict(checkpoint['net'])\n\n return net","def try_create_model_and_load_from_checkpoint(self) -> bool:\n self.create_model()\n if self.checkpoint_path:\n # Load the stored model. If there is no checkpoint present, return immediately.\n return self.try_load_checkpoint_for_model()\n return True","def load_model_trainer_states_from_checkpoint(self, checkpoint_path, model=None):\n import os\n\n if model is None:\n try:\n import cloudpickle\n except ImportError:\n raise ImportError(\"cloudpickle is required to load model class\")\n logger.info(\"Loading model class\")\n model = cloudpickle.load(open(os.path.join(checkpoint_path, \"model_class.pkl\"), \"rb\"))\n\n self.model = HFWrapper(model)\n logger.info(\"Loading weights of previously trained model\")\n # Restoring model weights\n self.model.load_state_dict(\n # torch.load(os.path.join(training_args.output_dir, \"pytorch_model.bin\"))\n torch.load(os.path.join(checkpoint_path, \"pytorch_model.bin\"))\n )\n # Restoring random state\n rng_file = os.path.join(checkpoint_path, \"rng_state.pth\")\n checkpoint_rng_state = torch.load(rng_file)\n random.setstate(checkpoint_rng_state[\"python\"])\n np.random.set_state(checkpoint_rng_state[\"numpy\"])\n torch.random.set_rng_state(checkpoint_rng_state[\"cpu\"])\n torch.cuda.random.set_rng_state_all(checkpoint_rng_state[\"cuda\"])\n # Restoring AMP scaler\n if self.use_amp:\n self.scaler.load_state_dict(torch.load(os.path.join(checkpoint_path, \"scaler.pt\")))","def load_model(path, model, optimizer):\n print(\"LOADING MODEL...\")\n ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)\n status = ckpt.restore(tf.train.latest_checkpoint(path))\n ckpt_manager = tf.train.CheckpointManager(\n checkpoint=ckpt, \n directory=FLAGS.model_dir, \n max_to_keep=3 \n )\n return model, optimizer, ckpt, ckpt_manager","def load_checkpoint(self, path: str = '', train: bool = True) -> int:\n\n if not path:\n dir_ = os.path.dirname(os.path.realpath('__file__'))\n path = os.path.join(dir_, 'model.pt')\n\n try:\n ckpt = torch.load(path)\n except FileNotFoundError:\n return 0\n else:\n print('Loaded model at epoch: ', end='')\n\n self.load_state_dict(ckpt['model_state_dict'])\n self.actor_optimizer.load_state_dict(ckpt['ac_optim_dict'])\n self.critic_optimizer.load_state_dict(ckpt['critic_optim_dict'])\n epoch = ckpt['epoch']\n\n print(epoch)\n\n if not train:\n self.eval()\n else:\n self.train()\n\n return epoch","def load_checkpoint(path: str, save_dir: str, cuda: bool = False, attention_viz: bool = False) -> nn.Module:\r\n # Load model and args\r\n state = torch.load(path, map_location=lambda storage, loc: storage)\r\n args, loaded_state_dict = state['args'], state['state_dict']\r\n\r\n # Update args with current args\r\n args.cuda = cuda\r\n args.attention_viz = attention_viz\r\n args.save_dir = save_dir\r\n\r\n model = build_model(args)\r\n model.load_state_dict(loaded_state_dict)\r\n\r\n if cuda:\r\n print('Moving model to cuda')\r\n model = model.cuda()\r\n\r\n return model","def init_model(config: Union[str, Path, Config],\n checkpoint: Optional[str] = None,\n device: str = 'cuda:0',\n cfg_options: Optional[dict] = None):\n if isinstance(config, (str, Path)):\n config = Config.fromfile(config)\n elif not isinstance(config, Config):\n raise TypeError('config must be a filename or Config object, '\n 'but got {}'.format(type(config)))\n if cfg_options is not None:\n config.merge_from_dict(cfg_options)\n elif 'init_cfg' in config.model.backbone:\n config.model.backbone.init_cfg = None\n config.model.pretrained = None\n config.model.train_cfg = None\n init_default_scope(config.get('default_scope', 'mmseg'))\n\n model = MODELS.build(config.model)\n if checkpoint is not None:\n checkpoint = load_checkpoint(model, checkpoint, map_location='cpu')\n dataset_meta = checkpoint['meta'].get('dataset_meta', None)\n # save the dataset_meta in the model for convenience\n if 'dataset_meta' in checkpoint.get('meta', {}):\n # mmseg 1.x\n model.dataset_meta = dataset_meta\n elif 'CLASSES' in checkpoint.get('meta', {}):\n # < mmseg 1.x\n classes = checkpoint['meta']['CLASSES']\n palette = checkpoint['meta']['PALETTE']\n model.dataset_meta = {'classes': classes, 'palette': palette}\n else:\n warnings.simplefilter('once')\n warnings.warn(\n 'dataset_meta or class names are not saved in the '\n 'checkpoint\\'s meta data, classes and palette will be'\n 'set according to num_classes ')\n num_classes = model.decode_head.num_classes\n dataset_name = None\n for name in dataset_aliases.keys():\n if len(get_classes(name)) == num_classes:\n dataset_name = name\n break\n if dataset_name is None:\n warnings.warn(\n 'No suitable dataset found, use Cityscapes by default')\n dataset_name = 'cityscapes'\n model.dataset_meta = {\n 'classes': get_classes(dataset_name),\n 'palette': get_palette(dataset_name)\n }\n model.cfg = config # save the config in the model for convenience\n model.to(device)\n model.eval()\n return model","def create_model( session, batch_size ):\n model = linear_model.LinearModel(\n FLAGS.linear_size,\n FLAGS.num_layers,\n FLAGS.residual,\n FLAGS.batch_norm,\n FLAGS.max_norm,\n batch_size,\n FLAGS.learning_rate,\n FLAGS.origin_bc,\n summaries_dir,\n dtype=tf.float16 if FLAGS.use_fp16 else tf.float32)\n\n if FLAGS.load <= 0:\n # Create a new model from scratch\n print(\"Creating model with fresh parameters.\")\n session.run( tf.global_variables_initializer() )\n return model\n\n # Load a previously saved model\n ckpt = tf.train.get_checkpoint_state( train_dir, latest_filename=\"checkpoint\")\n print( \"train_dir\", train_dir )\n\n if ckpt and ckpt.model_checkpoint_path:\n # Check if the specific cpixels = pixels / pixels[2,:]heckpoint exists\n if FLAGS.load > 0:\n if os.path.isfile(os.path.join(train_dir,\"checkpoint-{0}.index\".format(FLAGS.load))):\n ckpt_name = os.path.join( os.path.join(train_dir,\"checkpoint-{0}\".format(FLAGS.load)) )\n else:\n raise ValueError(\"Asked to load checkpoint {0}, but it does not seem to exist\".format(FLAGS.load))\n else:\n ckpt_name = os.path.basename( ckpt.model_checkpoint_path )\n\n print(\"Loading model {0}\".format( ckpt_name ))\n model.saver.restore( session, ckpt.model_checkpoint_path )\n return model\n else:\n print(\"Could not find checkpoint. Aborting.\")\n raise( ValueError, \"Checkpoint {0} does not seem to exist\".format( ckpt.model_checkpoint_path ) )\n\n return model","def load_from_checkpoint(results_dir, load_fn, args):\n ckpt_dir = os.path.join(results_dir, \"tb\", \"version_0\", \"checkpoints\")\n files = os.listdir(ckpt_dir)\n assert len(files) > 0, \"Checkpoint directory is empty\"\n ckpt_path = os.path.join(ckpt_dir, files[-1])\n model = load_fn(checkpoint_path=ckpt_path, args=args)\n return model","def try_load_checkpoint_for_model(self) -> bool:\n if self._model is None:\n raise ValueError(\"Model must be created before it can be adjusted.\")\n\n if not self.checkpoint_path:\n raise ValueError(\"No checkpoint provided\")\n\n if not self.checkpoint_path.is_file():\n logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')\n return False\n\n epoch = ModelAndInfo._load_checkpoint(model=self._model,\n checkpoint_path=self.checkpoint_path,\n key_in_state_dict=ModelAndInfo.MODEL_STATE_DICT_KEY,\n use_gpu=self.config.use_gpu)\n\n logging.info(f\"Loaded model from checkpoint (epoch: {epoch})\")\n self.checkpoint_epoch = epoch\n return True","def train_model(config: dict, load_weights=None, resume_epoch=None):\n # Set GPU memory optimization\n try:\n physical_devices = tf.config.list_physical_devices(\"GPU\")\n for index in range(len(physical_devices)):\n try:\n tf.config.experimental.set_memory_growth(physical_devices[index], True)\n\n except Exception as err:\n print(\"[WARN]: Failed to set memory growth for {0}\".format(physical_devices[index]))\n print(\"[WARN]: Error\", err, \" .Skipping memory optimization\")\n\n except Exception as err:\n print(\"[WARN]: memory optimization failed. Error:\", err, \" . Skipping!\")\n\n # Set up random states\n np.random.seed(100)\n random.seed(100)\n tf.random.set_seed(100)\n\n # Get the required configurations\n no_of_epochs = config[\"no_of_epochs\"]\n steps_per_epoch = config[\"steps_per_epoch\"] if config[\"steps_per_epoch\"] > 0 else None\n\n train_batch_size = config[\"train_batch_size\"]\n val_batch_size = config[\"val_batch_size\"]\n test_batch_size = config[\"test_batch_size\"]\n\n model_name = config[\"model_name\"]\n\n # Create the dataset\n dataset_path = config[\"dataset_path\"]\n dataset_family = config[\"dataset_family\"]\n\n # get width and height\n image_width = config[\"image_width\"]\n image_height = config[\"image_height\"]\n initial_width = config[\"initial_width\"]\n initial_height = config[\"initial_height\"]\n\n model_name = model_name + \"_\" + dataset_family\n\n print(\"[INFO]: Using Configuration: \\n\", config)\n\n # Set up environments\n folders = [\n \"./outputs/model_save/{0}/checkpoints/\".format(model_name),\n \"./outputs/output_logs/{0}/csv_log/\".format(model_name),\n \"./outputs/model_save/{0}/best_model/\".format(model_name),\n \"./outputs/model_save/{0}/saved_model/\".format(model_name),\n \"./outputs/output_logs/{0}/graphs/\".format(model_name)\n ]\n print(\"[INFO]: Setting up folders: \")\n os_utilities.make_directories(paths=folders)\n\n # Load the dataset\n print(\"[INFO]: Loading dataset\")\n if dataset_family == \"CVC-ClinicDB\":\n X, y = du.get_cvc_clinic_datapath(dataset_path)\n elif dataset_family == \"Kvasir-Seg\":\n X, y = du.get_kvasir_seg_datapath(dataset_path)\n else:\n print(\"[ERROR]: {0} dataset family is unrecognized or not supported!\".format(dataset_family))\n raise NotImplementedError\n\n X_train, X_sided, y_train, y_sided = train_test_split(X, y, random_state=100, test_size=0.2)\n X_val, X_test, y_val, y_test = train_test_split(X_sided, y_sided, random_state=100, test_size=0.5)\n\n print(\"[INFO]: Training set size: \", len(X_train))\n print(\"[INFO]: Validation set size: \", len(X_val))\n print(\"[INFO]: Testing set size: \", len(X_test))\n\n print(\"[INFO]: Loading Training set\")\n train_datagen = du.DataGenerator(X_train,\n y_train,\n image_size=(image_width, image_height),\n model_name=config[\"model_name\"],\n batch_size=train_batch_size,\n dataset_family=dataset_family,\n initial_size=(initial_width, initial_height),\n aug_config_path=\"./augmentation_config.yaml\",\n shuffle=True)\n\n print(\"[INFO]: Loading Validation set\")\n val_datagen = du.DataGenerator(X_val,\n y_val,\n image_size=(image_width, image_height),\n model_name=config[\"model_name\"],\n batch_size=val_batch_size,\n dataset_family=dataset_family,\n initial_size=None,\n aug_config_path=None,\n shuffle=False)\n\n print(\"[INFO]: Setting tf.data pipeline\")\n train_steps = len(train_datagen) if steps_per_epoch is None else int(steps_per_epoch)\n val_steps = len(val_datagen)\n\n train_dataset = train_datagen.get_tf_data()\n val_dataset = val_datagen.get_tf_data()\n\n # Get the model, loss and metrics\n print(\"[INFO]: Building the model - {0}\".format(model_name))\n model = models.ModelSelector(config)\n\n # Load the weights if available\n if load_weights is not None:\n print(\"[INFO]: Load the weights from {0}\".format(load_weights))\n model.load_weights(load_weights)\n\n # Setup Callbacks\n print(\"[INFO]: Setting up training Callbacks and Optimizers. Its almost done\")\n resume_epoch = 0 if resume_epoch is None else resume_epoch\n overwrite = True if resume_epoch == 0 else False\n\n train_csv_logger = callbacks.CSVLogging(\"./outputs/output_logs/{0}/csv_log/train_log.csv\".format(model_name),\n overwrite=overwrite)\n valid_csv_logger = callbacks.CSVLogging(\"./outputs/output_logs/{0}/csv_log/valid_log.csv\".format(model_name),\n overwrite=overwrite)\n lr_reducer = callbacks.ReduceLROnPlateau(learning_rate=float(config[\"learning_rate\"]),\n patience=4,\n decay_rate=1E-1,\n delta=0.0001,\n min_lr=1E-7,\n mode=\"min\")\n\n model_save_path = \"./outputs/model_save/{0}/\".format(model_name)\n\n # Setup Optimizer\n optimizer = tf.keras.optimizers.Adam(learning_rate=float(config[\"learning_rate\"]))\n\n # Check for monitor\n monitor_variable = 100.0 # Initialize a start max\n\n print(\"[INFO]: Setting up metrics\")\n loss_avg = tf.keras.metrics.Mean(name=\"loss\")\n f1_score_metric = tf.keras.metrics.Mean(name=\"f1_score\")\n iou_coe_metric = tf.keras.metrics.Mean(name=\"iou_coe\")\n dice_coe_metric = tf.keras.metrics.Mean(name=\"dice_coe\")\n\n # Set up a custom train loop\n print(\"[INFO]: Beginning training loops\")\n # Iterate epoch wise\n for epoch in range(resume_epoch, no_of_epochs):\n\n print(\"Training {0}/{1}\".format(epoch + 1, no_of_epochs))\n\n try:\n # Training-loop == using batches\n train_loss, train_f1_score, train_iou, train_dice = train(config[\"model_name\"],\n model,\n train_dataset,\n train_steps,\n metrics_tracker=(loss_avg,\n f1_score_metric,\n iou_coe_metric,\n dice_coe_metric),\n optimizer=optimizer,\n epoch=epoch + 1,\n total_epochs=no_of_epochs)\n\n train_tracker = {\n \"train_loss\": [train_loss],\n \"train_f1_score\": [train_f1_score],\n \"train_iou_coe\": [train_iou],\n \"train_dice_coe\": [train_dice]\n }\n\n # Validation loop == using batches\n val_loss, val_f1_score, val_iou, val_dice = train(config[\"model_name\"],\n model,\n val_dataset,\n val_steps,\n metrics_tracker=(loss_avg,\n f1_score_metric,\n iou_coe_metric,\n dice_coe_metric),\n optimizer=None,\n epoch=1,\n total_epochs=1)\n val_tracker = {\n \"val_loss\": [val_loss],\n \"val_f1_score\": [val_f1_score],\n \"val_iou_coe\": [val_iou],\n \"val_dice_coe\": [val_dice]\n }\n\n model.save_weights(model_save_path + \"checkpoints/{0}_ckpt.h5\".format(model_name))\n print(\"[INFO]: Epoch {0}/{1} - \\nTrain evaluation: {2}, \\nValidation evaluation: {3}\".\n format(epoch + 1, no_of_epochs, train_tracker, val_tracker))\n train_csv_logger.log(train_tracker)\n valid_csv_logger.log(val_tracker)\n\n # Save the best model\n if monitor_variable > val_loss:\n monitor_variable = val_loss\n model.save_weights(model_save_path + \"best_model/best_{0}.h5\".format(model_name))\n\n # LR Reduce\n lr_reducer.check_lr(monitor_variable=val_loss, optimizer=optimizer)\n\n except KeyboardInterrupt:\n print(\"[INFO]: Interrupted Training. Trying to save model\")\n model.save_weights(model_save_path + \"{0}_{1}_interrupted.h5\".format(model_name, epoch + 1))\n print(\"[INFO]: Attempting to run test on the best model so far!\")\n break\n\n except Exception as err:\n print(\"[ERROR]: Unexpected Critical Error: \", err)\n print(\"[ERROR]: Trying to save the weights\")\n model.save_weights(model_save_path + \"{0}_{1}_critical.h5\".format(model_name, epoch + 1))\n traceback.print_exc()\n sys.exit(2)\n\n print(\"[INFO]: Training completed. Saving model\")\n model.save_weights(model_save_path + \"saved_model/{0}.h5\".format(model_name))\n\n print(\"[INFO]: Testing model\")\n print(\"[INFO]: Loading Best saved model:\")\n model.load_weights(model_save_path + \"best_model/best_{0}.h5\".format(model_name))\n\n print(\"[INFO]: Loading the test set\")\n test_datagen = du.DataGenerator(X_test,\n y_test,\n image_size=(image_width, image_height),\n model_name=config[\"model_name\"],\n batch_size=test_batch_size,\n dataset_family=dataset_family,\n initial_size=None,\n aug_config_path=None,\n shuffle=False)\n\n print(\"[INFO]: Loading TF data\")\n test_dataset = test_datagen.get_tf_data()\n test_steps = len(test_datagen)\n\n print(\"[INFO]: Testing Initiated\")\n test_loss, test_f1_score, test_iou, test_dice = train(config[\"model_name\"],\n model,\n test_dataset,\n test_steps,\n metrics_tracker=(loss_avg,\n f1_score_metric,\n iou_coe_metric,\n dice_coe_metric),\n optimizer=None,\n epoch=1,\n total_epochs=1)\n test_tracker = {\n \"test_loss\": [test_loss],\n \"test_f1_score\": [test_f1_score],\n \"test_iou_coe\": [test_iou],\n \"test_dice_coe\": [test_dice]\n }\n print(\"[INFO]: Test Results: \\n\", test_tracker)\n with open(\"./outputs/output_logs/{0}/test_results.txt\".format(model_name), mode=\"w\") as f:\n f.write(\"Dumped Test Results for the model {0}\\n\".format(model_name))\n for k, v in test_tracker.items():\n f.write(\"{0} => {1}\\n\".format(k, v))\n\n print(\"[INFO]: Closing operations\")","def create_reference_model(self, config, tmp_path_factory: pytest.TempPathFactory, *args):\n config = copy.deepcopy(config) # ensure the reference model is not passed to tests\n\n save_folder = tmp_path_factory.mktemp('{device}-{precision}'.format(**config))\n config.update({'save_interval': '1ep', 'save_folder': str(save_folder), 'save_filename': 'ep{epoch}.pt'})\n\n trainer = Trainer(**config)\n trainer.fit()\n\n self.reference_model = trainer.state.model\n self.reference_folder = save_folder","def load_checkpoint(cfg, args):\n checkpoint_iteration = args.checkpoint\n bucket = connect_to_bucket(args.bucket)\n # load actual checkpoint\n if not os.path.isdir(cfg.OUTPUT_DIR):\n os.mkdir(cfg.OUTPUT_DIR)\n blob = bucket.blob(cfg.OUTPUT_DIR + \"/model_\" + str(checkpoint_iteration) + \".pth\")\n blob.download_to_filename(cfg.OUTPUT_DIR + \"/model_\" + str(checkpoint_iteration) + \".pth\")\n if args.resume:\n # also write last checkpoint file for when --resume statement, model gets checkpoint name from this file\n with open(cfg.OUTPUT_DIR + \"/last_checkpoint\", \"w\") as file:\n file.write(\"model_\" + str(checkpoint_iteration) + \".pth\")\n # return statement not clean, but useful for inference code\n return checkpoint_iteration, bucket","def load_checkpoint(self, session, model_dir):\n assert self.params.cp_load == True, (\"cp_load must be set to true to load a checkpoint\")\n self.loader.restore(session, model_dir)","def init_model(session, model):\n # If there is a checkpoint, load it\n if not tf.gfile.Exists(FLAGS.train_dir):\n tf.gfile.MkDir(FLAGS.train_dir)\n ckpt = tf.train.get_checkpoint_state(FLAGS.train_dir)\n if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path):\n print(\"Reading model parameters from %s\" % ckpt.model_checkpoint_path)\n model.saver.restore(session, ckpt.model_checkpoint_path)\n\n # Else initialize the variables\n else:\n if FLAGS.decode:\n input(\"You sure you want to talk to an untrained chatbot? Press Ctrl-C to stop, Return to continue \")\n print(\"Fine.\")\n\n print(\"Creating model with fresh parameters.\")\n session.run(tf.global_variables_initializer())","def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):\n\n config = kwargs.pop(\"config\", None)\n state_dict = kwargs.pop(\"state_dict\", None)\n cache_dir = kwargs.pop(\"cache_dir\", None)\n from_tf = kwargs.pop(\"from_tf\", False)\n from_hf = kwargs.pop(\"from_hf\", False)\n output_loading_info = kwargs.pop(\"output_loading_info\", False)\n default_gpu = kwargs.pop(\"default_gpu\", True)\n\n # Load config\n assert config is not None\n model_kwargs = kwargs\n\n # Load model\n if pretrained_model_name_or_path in cls.pretrained_model_archive_map:\n archive_file = cls.pretrained_model_archive_map[pretrained_model_name_or_path]\n elif os.path.isdir(pretrained_model_name_or_path):\n if from_tf:\n # Directly load from a TensorFlow checkpoint\n archive_file = os.path.join(pretrained_model_name_or_path, TF_WEIGHTS_NAME + \".index\")\n else:\n archive_file = os.path.join(pretrained_model_name_or_path, WEIGHTS_NAME)\n else:\n if from_tf:\n # Directly load from a TensorFlow checkpoint\n archive_file = pretrained_model_name_or_path + \".index\"\n else:\n archive_file = pretrained_model_name_or_path\n # redirect to the cache, if necessary\n try:\n resolved_archive_file = cached_path(archive_file, cache_dir=cache_dir)\n except EnvironmentError:\n if pretrained_model_name_or_path in cls.pretrained_model_archive_map:\n logger.error(\"Couldn't reach server at '{}' to download pretrained weights.\".format(archive_file))\n else:\n logger.error(\n \"Model name '{}' was not found in model name list ({}). \"\n \"We assumed '{}' was a path or url but couldn't find any file \"\n \"associated to this path or url.\".format(\n pretrained_model_name_or_path, \", \".join(cls.pretrained_model_archive_map.keys()), archive_file)\n )\n return None\n if default_gpu:\n if resolved_archive_file == archive_file:\n logger.info(\"loading weights file {}\".format(archive_file))\n else:\n logger.info(\"loading weights file {} from cache at {}\".format(archive_file, resolved_archive_file))\n\n # Instantiate model.\n model = cls(config, *model_args, **model_kwargs)\n\n if state_dict is None and not from_tf:\n state_dict = torch.load(resolved_archive_file, map_location=\"cpu\")\n if from_tf:\n # Directly load from a TensorFlow checkpoint\n return cls.load_tf_weights(model, config, resolved_archive_file[:-6]) # Remove the '.index'\n\n # Convert old format to new format if needed from a PyTorch state_dict\n old_keys = []\n new_keys = []\n for key in state_dict.keys():\n new_key = None\n if \"gamma\" in key:\n new_key = key.replace(\"gamma\", \"weight\")\n if \"beta\" in key:\n new_key = key.replace(\"beta\", \"bias\")\n if new_key:\n old_keys.append(key)\n new_keys.append(new_key)\n for old_key, new_key in zip(old_keys, new_keys):\n state_dict[new_key] = state_dict.pop(old_key)\n\n # Rename Bert parameters for our framework\n # NB: Assume 1 Bert layer is mapped to 1 layer only (cannot be used to init multiple layers)\n old_keys = []\n new_keys = []\n nums = []\n for key in state_dict.keys():\n new_key = None\n if \".layer.\" in key and from_hf:\n num = int(key.split(\".layer.\")[-1].split(\".\")[0])\n if \".attention.\" in key:\n new_key = key.replace(\".layer.%d.attention.\" % num,\n \".layer.%d.attention_\" % config.bert_layer2attn_sublayer.get(str(num), num))\n elif \".intermediate.\" in key:\n new_key = key.replace(\".layer.%d.intermediate.\" % num,\n \".layer.%d.intermediate.\" % config.bert_layer2ff_sublayer.get(str(num), num))\n elif \".output.\" in key:\n new_key = key.replace(\".layer.%d.output.\" % num,\n \".layer.%d.output.\" % config.bert_layer2ff_sublayer.get(str(num), num))\n if new_key:\n old_keys.append(key)\n new_keys.append(new_key)\n nums.append(num)\n for old_key, new_key, _ in sorted(zip(old_keys, new_keys, nums), key=lambda x: x[2], reverse=True):\n state_dict[new_key] = state_dict.pop(old_key)\n\n # Load from a PyTorch state_dict\n missing_keys = []\n unexpected_keys = []\n error_msgs = []\n # copy state_dict so _load_from_state_dict can modify it\n metadata = getattr(state_dict, \"_metadata\", None)\n state_dict = state_dict.copy()\n if metadata is not None:\n state_dict._metadata = metadata\n\n def load(module, prefix=\"\"):\n local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {})\n module._load_from_state_dict(\n state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs,\n )\n for name, child in module._modules.items():\n if child is not None:\n load(child, prefix + name + \".\")\n\n # Make sure we are able to load base models as well as derived models (with heads)\n start_prefix = \"\"\n model_to_load = model\n if not hasattr(model, cls.base_model_prefix) and any(\n s.startswith(cls.base_model_prefix) for s in state_dict.keys()\n ):\n start_prefix = cls.base_model_prefix + \".\"\n if hasattr(model, cls.base_model_prefix) and not any(\n s.startswith(cls.base_model_prefix) for s in state_dict.keys()\n ):\n model_to_load = getattr(model, cls.base_model_prefix)\n\n logger.info(start_prefix)\n load(model_to_load, prefix=start_prefix)\n if len(missing_keys) > 0 and default_gpu:\n logger.info(\n \"Weights of {} not initialized from pretrained model: {}\".format(model.__class__.__name__, missing_keys)\n )\n if len(unexpected_keys) > 0 and default_gpu:\n logger.info(\n \"Weights from pretrained model not used in {}: {}\".format(model.__class__.__name__, unexpected_keys)\n )\n if len(error_msgs) > 0 and default_gpu:\n raise RuntimeError(\n \"Error(s) in loading state_dict for {}:\\n\\t{}\".format(model.__class__.__name__, \"\\n\\t\".join(error_msgs))\n )\n\n if hasattr(model, \"tie_weights\"):\n model.tie_weights() # make sure word embedding weights are still tied\n\n # Set model in evaluation mode to desactivate DropOut modules by default\n model.eval()\n\n if output_loading_info:\n loading_info = {\n \"missing_keys\": missing_keys,\n \"unexpected_keys\": unexpected_keys,\n \"error_msgs\": error_msgs,\n }\n return model, loading_info\n\n return model","def load_ckpt(self, name=None):\r\n name = name if name == 'latest' else \"ckpt_epoch{}\".format(name)\r\n load_path = os.path.join(self.model_dir, \"{}.pth\".format(name))\r\n if not os.path.exists(load_path):\r\n raise ValueError(\"Checkpoint {} not exists.\".format(load_path))\r\n\r\n checkpoint = torch.load(load_path)\r\n print(\"Checkpoint loaded from {}\".format(load_path))\r\n if isinstance(self.net, nn.DataParallel):\r\n self.net.module.load_state_dict(checkpoint['model_state_dict'])\r\n else:\r\n self.net.load_state_dict(checkpoint['model_state_dict'])\r\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\r\n self.scheduler.load_state_dict(checkpoint['scheduler_state_dict'])\r\n self.clock.restore_checkpoint(checkpoint['clock'])","def load_checkpoint(ckpt_path):\n checkpoint = None\n if ckpt_path:\n logger.info(\"Loading checkpoint from %s\" % ckpt_path)\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\"cpu\"))\n\n if \"model\" in checkpoint.keys():\n # This preserves backward-compat for models using customed layernorm\n def fix_key(s):\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.b_2\", r\"\\1.layer_norm\\2.bias\", s\n )\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.a_2\", r\"\\1.layer_norm\\2.weight\", s\n )\n return s\n\n checkpoint[\"model\"] = {\n fix_key(k): v for k, v in checkpoint[\"model\"].items()\n }\n # Force add_ffnbias to True if bias found in model w_1 keys\n for key in checkpoint[\"model\"].keys():\n if \"w_1.bias\" in key:\n checkpoint[\"opt\"].add_ffnbias = True\n\n if not hasattr(checkpoint[\"opt\"], \"num_kv\"):\n checkpoint[\"opt\"].num_kv = 0\n if not hasattr(checkpoint[\"opt\"], \"add_ffnbias\"):\n checkpoint[\"opt\"].add_ffnbias = False\n if not hasattr(checkpoint[\"opt\"], \"parallel_residual\"):\n checkpoint[\"opt\"].parallel_residual = False\n if not hasattr(checkpoint[\"opt\"], \"shared_layer_norm\"):\n checkpoint[\"opt\"].shared_layer_norm = False\n if not hasattr(checkpoint[\"opt\"], \"use_ckpting\"):\n checkpoint[\"opt\"].use_ckpting = []\n if not hasattr(checkpoint[\"opt\"], \"relative_positions_buckets\"):\n checkpoint[\"opt\"].relative_positions_buckets = 0\n if not hasattr(checkpoint[\"opt\"], \"parallel_mode\"):\n checkpoint[\"opt\"].parallel_mode = \"data_parallel\"\n if not hasattr(checkpoint[\"opt\"], \"norm_eps\"):\n checkpoint[\"opt\"].norm_eps = 1e-6\n\n # fix v2 compatibility\n if \"generator\" in checkpoint.keys() and checkpoint[\"generator\"]:\n if \"0.weight\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"weight\"] = checkpoint[\"generator\"].pop(\n \"0.weight\"\n )\n if \"0.bias\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"bias\"] = checkpoint[\"generator\"].pop(\"0.bias\")\n # end of patch for backward compatibility\n\n return checkpoint","def load_checkpoint(self, model):\n print(f\"load model {self.save_model_path}\")\n model.load_state_dict(torch.load(self.save_model_path))","def load(loadname, checkpoint=None):\n ckpt_dir = \"./models/tf_ckpt_\" + loadname + \"/\"\n if checkpoint is not None:\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\n status.assert_consumed()\n print(\"Loaded checkpoint\")\n else:\n print(\"Not Loading any checkpoint\")\n print(\"Starting training from initial configuration\")","def _init_model(self, checkpoint_path: str) -> None:\n # load weights\n logger.info(f\"Load weights from the checkpoint {checkpoint_path}\")\n checkpoint = torch.load(checkpoint_path, map_location=torch.device(\"cpu\"))\n\n state_dict = checkpoint[\"state_dict\"]\n self.orig_acc = checkpoint[\"test_acc\"]\n\n is_pruned = (\n next((name for name in state_dict if \"mask\" in name), None) is not None\n )\n\n if is_pruned:\n logger.info(\"Dummy prunning to load pruned weights\")\n model_utils.dummy_pruning(self.params_all)\n\n model_utils.initialize_params(self.model, state_dict)\n logger.info(\"Initialized weights\")\n\n # check the trained model is pruned\n\n if is_pruned:\n logger.info(\n \"Get masks and remove prunning reparameterization for prepare_qat\"\n )\n self.mask = model_utils.get_masks(self.model)\n model_utils.remove_pruning_reparameterization(self.params_all)","def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\n print(\"Loading checkpoint: {}\".format(checkpoint_path))\n state = torch.load(checkpoint_path)\n self.model.load_state_dict(state['state_dict'])\n self.optimizer.load_state_dict(state['optim_dict'])\n\n if continue_from_epoch:\n self.epoch = state['epoch']","def load_model(self, ckpt_name=\"best_model.pth\"):\n path = \"/\".join(ckpt_name.split(\"/\")[:-1])\n chkpt = torch.load(ckpt_name)\n self.start_epoch = chkpt['epoch']\n self.best_metric = chkpt['best_metric']\n\n # fix the DataParallel caused problem with keys names\n if self.multi_gpu_flag:\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=False)\n self.net.load_state_dict(new_state_dict)\n else:\n try:\n self.net.load_state_dict(chkpt['state_dict'])\n except:\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=True)\n self.net.load_state_dict(new_state_dict)\n\n if self.load_optimizer_state:\n self.optimizer.load_state_dict(chkpt['optimizer'])\n logging.info(\"******** State loaded ********\")\n\n training_meta = pickle.load(open(f\"{path}/training_meta.pickle.dat\", \"rb\"))\n for k, v in training_meta.items():\n if k in self.__class__.__params:\n setattr(self, k, v)\n logging.info(\"******** Training params loaded ********\")","def create_model(model_name, random_state, epoch, device, log_path, **hparams):\n model = eval(f'{model_name}')(\n **hparams, epoch=int(epoch), random_state=random_state, device=device,\n log_path=log_path\n )\n\n return model","def create_checkpoint(model, save_dir, train_data):\n model.class_to_idx = train_data.class_to_idx\n\n checkpoint = {\n 'model': model.name,\n 'classifier': model.classifier,\n 'class_to_idx': model.class_to_idx,\n 'state_dict': model.state_dict()\n }\n\n if save_dir and isdir(save_dir):\n torch.save(checkpoint, save_dir + 'checkpoint.pth')\n print('checkpoint created')\n else: \n print(\"Directory not found. Saving at current directory in checkpoint.pth\")\n torch.save(checkpoint, 'checkpoint.pth')","def __init__(self, model: str, **kwargs):\n super().__init__(model=model, **kwargs)\n self.path = model\n self.model = get_zennet()\n\n model_pth_path = osp.join(self.path, ModelFile.TORCH_MODEL_FILE)\n\n checkpoint = torch.load(model_pth_path, map_location='cpu')\n if 'state_dict' in checkpoint:\n state_dict = checkpoint['state_dict']\n else:\n state_dict = checkpoint\n\n self.model.load_state_dict(state_dict, strict=True)\n logger.info('load model done')","def load_checkpoint(self, checkpoint_dir):\r\n\r\n if not os.path.exists(checkpoint_dir):\r\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\r\n\r\n path = os.path.join(checkpoint_dir, 'model.pt')\r\n self.model.load_state_dict(torch.load(path, self.device))\r\n self.update()","def get_checkpoint(model, checkpoint='-1'):\n if not os.path.isfile(os.path.join(model, \"checkpoint\")):\n sys.exit(\"[ERROR] Cannot find checkpoint in %s.\" % model)\n ckpt = tf.train.get_checkpoint_state(model)\n\n model_checkpoint_path = ckpt.model_checkpoint_path\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\n\n if not ckpt or not model_checkpoint_path:\n sys.exit(\"[ERROR] Cannot read checkpoint %s.\" % os.path.join(model, \"checkpoint\"))\n\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\n steps = sorted(steps)\n if checkpoint == \"last\":\n tf.logging.info(\"Load the last saved model.\")\n checkpoint = steps[-1]\n else:\n checkpoint = int(checkpoint)\n if checkpoint == -1:\n tf.logging.info(\"Load the best model according to valid_loss\")\n min_epoch = -1\n min_loss = 1e10\n with open(os.path.join(model, \"valid_loss\")) as f:\n for line in f.readlines():\n epoch, loss, eer = line.split(\" \")\n epoch = int(epoch)\n loss = float(loss)\n if loss < min_loss:\n min_loss = loss\n min_epoch = epoch\n # Add 1 to min_epoch since epoch is 0-based\n config_json = os.path.join(model, \"config.json\")\n params = Params(config_json)\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\n tf.logging.info(\"The checkpoint is %d\" % checkpoint)\n assert checkpoint in steps, \"The checkpoint %d not in the model directory\" % checkpoint\n\n model_checkpoint_path = model_checkpoint_path.rsplit(\"-\", 1)[0] + \"-\" + str(checkpoint)\n model_checkpoint_path = os.path.join(model, os.path.basename(model_checkpoint_path))\n\n with open(os.path.join(model, \"checkpoint\"), \"w\") as f:\n f.write(\"model_checkpoint_path: \\\"%s\\\"\\n\" % model_checkpoint_path)\n for checkpoint in all_model_checkpoint_paths:\n checkpoint_new = os.path.join(model, os.path.basename(checkpoint))\n f.write(\"all_model_checkpoint_paths: \\\"%s\\\"\\n\" % checkpoint_new)\n return model_checkpoint_path","def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\n print(\"Load checkpoint from: {}\".format(path))\n state_dict, optimizer_state = _load(path)\n\n model.load_dict(state_dict)\n if not reset_optimizer and optimizer is not None:\n if optimizer_state is not None:\n print(\"[loading] Load optimizer state from {}\".format(path))\n optimizer.load(optimizer_state)\n\n return model","def initialize_model_from_cfg(args, gpu_id=0):\n model = eval(args.model).loot_model(args)\n model.eval()\n\n if args.cuda:\n model.cuda()\n\n if args.load_ckpt:\n load_name = args.load_ckpt\n logger.info(\"loading checkpoint %s\", load_name)\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\n net_utils.load_ckpt(model, checkpoint['model'])\n\n if args.load_detectron:\n logger.info(\"loading detectron weights %s\", args.load_detectron)\n load_detectron_weight(model, args.load_detectron)\n\n\n return model","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint)\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\n self.model.load_state_dict(checkpoint[\"model_state_dict\"])\n self.optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n return self","def _load_weights_to_model(self, model: nn.Module,\n checkpoint: Optional[dict],\n cfg: Optional[ConfigType]) -> None:\n if checkpoint is not None:\n _load_checkpoint_to_model(model, checkpoint)\n else:\n warnings.warn('Checkpoint is not loaded, and the inference '\n 'result is calculated by the randomly initialized '\n 'model!')","def load_checkpoint(model, save_path):\n model.load_state_dict(torch.load(save_path))","def load_checkpoint(model, model_name='model', validation_id=None):\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\n _load_model(model.module if type(model) is torch.nn.DataParallel else model, model_name, path=path, reload=True)","def load_model(self, fname: str) -> None:\n checkpoint_data = torch.load(fname)\n\n # Load the models\n # P-Net\n model_import_path = checkpoint_data['p_net']['model_import_path']\n imp = importlib.import_module(model_import_path)\n mod = getattr(imp, checkpoint_data['p_net']['model_name'])\n self.p_net = mod()\n self.p_net.set_params(checkpoint_data['p_net'])\n # Q-Net\n model_import_path = checkpoint_data['q_net']['model_import_path']\n imp = importlib.import_module(model_import_path)\n mod = getattr(imp, checkpoint_data['q_net']['model_name'])\n self.q_net = mod()\n self.q_net.set_params(checkpoint_data['q_net'])","def load_model (checkpoint_path, model, opt_fn=None, loss_fn=None, epoch=None):\n\n if not os.path.exists(checkpoint_path):\n raise Exception (\"The {} does not exist!\".format(checkpoint_path))\n\n ckpt = torch.load(checkpoint_path)\n model.load_state_dict(ckpt['model_state_dict'])\n\n if opt_fn is not None and loss_fn is not None:\n opt_fn.load_state_dict(ckpt['optimizer_state_dict'])\n epoch = ckpt['epoch']\n loss_fn = ckpt['loss']\n return model, opt_fn, loss_fn, epoch\n else:\n return model","def checkpoint_load(checkpoint_path, gpu):\n model_info = torch.load(checkpoint_path)\n model = models.vgg19(pretrained=True)\n for param in model.parameters():\n param.requires_grad = False\n \n model.class_to_idx = model_info['class_to_idx']\n\n model = classifier(model)\n model.load_state_dict(model_info[\"model_state_dict\"])\n return model, model.class_to_idx","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load(self, checkpoint_dir=None):\n\n if checkpoint_dir is None:\n checkpoint_dir = FLAGS.checkpoint_dir\n\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n\n return self.load_from_path(checkpoint_dir)","def get_pretrain_model(pretrain_model, target_model, checkpoint='-1'):\n if not os.path.isfile(os.path.join(pretrain_model, \"checkpoint\")):\n sys.exit(\"[ERROR] Cannot find checkpoint in %s.\" % pretrain_model)\n ckpt = tf.train.get_checkpoint_state(pretrain_model)\n\n model_checkpoint_path = ckpt.model_checkpoint_path\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\n\n if not ckpt or not model_checkpoint_path:\n sys.exit(\"[ERROR] Cannot read checkpoint %s.\" % os.path.join(pretrain_model, \"checkpoint\"))\n\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\n steps = sorted(steps)\n\n if checkpoint == \"last\":\n tf.logging.info(\"Load the last saved model.\")\n checkpoint = steps[-1]\n else:\n checkpoint = int(checkpoint)\n if checkpoint == -1:\n tf.logging.info(\"Load the best model according to valid_loss\")\n min_epoch = -1\n min_loss = 1e10\n with open(os.path.join(pretrain_model, \"valid_loss\")) as f:\n for line in f.readlines():\n epoch, loss, eer = line.split(\" \")\n epoch = int(epoch)\n loss = float(loss)\n if loss < min_loss:\n min_loss = loss\n min_epoch = epoch\n # Add 1 to min_epoch since epoch is 0-based\n config_json = os.path.join(pretrain_model, \"config.json\")\n params = Params(config_json)\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\n assert checkpoint in steps, \"The checkpoint %d not in the model directory\" % checkpoint\n\n pretrain_model_checkpoint_path = model_checkpoint_path.rsplit(\"-\", 1)[0] + \"-\" + str(checkpoint)\n tf.logging.info(\"Copy the pre-trained model %s as the fine-tuned initialization\" % pretrain_model_checkpoint_path)\n\n import glob\n for filename in glob.glob(pretrain_model_checkpoint_path + \"*\"):\n bas = os.path.basename(filename).split(\"-\", 1)[0]\n ext = os.path.basename(filename).rsplit(\".\", 1)[1]\n shutil.copyfile(filename, os.path.join(target_model, bas + \"-0.\" + ext))\n\n with open(os.path.join(target_model, \"checkpoint\"), \"w\") as f:\n f.write(\"model_checkpoint_path: \\\"%s\\\"\\n\" % os.path.join(target_model, os.path.basename(model_checkpoint_path).rsplit(\"-\", 1)[0] + \"-0\"))\n f.write(\"all_model_checkpoint_paths: \\\"%s\\\"\\n\" % os.path.join(target_model, os.path.basename(model_checkpoint_path).rsplit(\"-\", 1)[0] + \"-0\"))\n return","def train(self, config: ConfigurationNode = None):\n if config is None:\n config = self.config\n # Create writable timestamp for easier record keeping\n timestamp = datetime.now().isoformat(sep=\"T\", timespec=\"auto\")\n name_timestamp = timestamp.replace(\":\", \"_\")\n\n # Start the mlflow run:\n mlflow.start_run(run_name=name_timestamp)\n\n # Check valid output path, set path from the path_cfg_override modules respectively\n assert config.OUTPUT_PATH != ''\n path_output = config.OUTPUT_PATH # output folder\n path_train = config.DATASET.TRAIN_DATA_PATH # training data folder\n path_val = config.DATASET.VAL_DATA_PATH # validation data folder\n\n # Make output dir and its parents if not exist.\n if not os.path.exists(path_output):\n os.makedirs(path_output)\n\n # Make result folders if they do not exist.\n self.results_dir = (Path(path_output) / name_timestamp)\n if not os.path.exists(self.results_dir):\n os.makedirs(self.results_dir)\n\n # Make backup folders if they do not exist.\n self.backup_dir = os.path.join(self.results_dir, 'model_backups')\n if not os.path.exists(self.backup_dir):\n os.makedirs(self.backup_dir)\n\n writer_tensorboard = SummaryWriter(log_dir=Path(self.results_dir / \"logs_tensorflow\"))\n\n # Now that CFG has been properly merged with new data along the way, time to dump a version of it into a string for trackability purposes.\n config.dump(stream=open(os.path.join(self.results_dir, f'config{name_timestamp}.yaml'), 'w'))\n\n # file path to store the state of the model.\n state_fpath = os.path.join(self.results_dir, f'model{name_timestamp}.pt')\n\n # ????\n perf_path = os.path.join(self.results_dir, f'trace{name_timestamp}.p')\n perf_trace = []\n\n # Load data, create the data loader objects from them.\n data_train = pickle.load(open(path_train, 'rb'))\n data_val = pickle.load(open(path_val, 'rb'))\n self.loader_train = build_data_loader(data_train, config.DATASET, True)\n self.loader_val = build_data_loader(data_val, config.DATASET, False)\n\n # Build the model using configue dict node\n self.model = build_model(config.MODEL)\n\n # Enable parallel multi GPU mode if the config specify it.\n if config.MODEL.PARALLEL:\n print(\"Utilized parallel processing\")\n self.model = torch.nn.DataParallel(self.model)\n\n current_epoch = 0\n\n # For resuming training (i.e. load checkpoint)\n if config.RESUME_PATH != \"\":\n checkpoint = torch.load(config.RESUME_PATH, map_location='cpu')\n current_epoch = checkpoint['epoch']\n self.model.load_state_dict(checkpoint[\"model_state\"])\n _ = self.model.cuda()\n\n # SOLVER EVALUATOR\n cfg_solver = config.MODEL.SOLVER\n\n # Build optimizer (between train/validation, using the solver portion of the configuration.\n optimizer = build_optimizer(self.model, cfg_solver)\n\n # Build evaluator (between train/validation, using the solver portion of the configuration.\n evaluator = build_evaluator(cfg_solver)\n\n evaluator.float().cuda()\n total_epochs = cfg_solver.TOTAL_EPOCHS\n\n\n # Main training epoch loop starts here.\n for epoch in range(current_epoch, total_epochs):\n\n # Train a single epoch\n self.train_epoch(epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard)\n\n mlflow.end_run()","def eval_model(config):\n print 'Model directory: %s' % config.model_output\n print 'Running model: %s' % config.model_type\n if config.model_type == 'fully_connected_mlp':\n from models.fully_connected_mlp import model_struct\n elif config.model_type == 'fully_connected_mlp_2l':\n from models.fully_connected_mlp_2l import model_struct\n elif config.model_type == 'fully_connected_conv':\n from models.fully_connected_conv import model_struct\n elif config.model_type == 'vgg_feature_model':\n from models.vgg_feature_model import model_struct\n else:\n raise Exception\n\n # Prepare model training\n dt_stamp = re.split(\n '\\.', str(datetime.now()))[0].\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\n dt_dataset = config.model_type + '_' + dt_stamp + '/'\n config.train_checkpoint = os.path.join(\n config.model_output, dt_dataset) # timestamp this run\n config.summary_dir = os.path.join(\n config.train_summaries, config.model_output, dt_dataset)\n dir_list = [config.train_checkpoint, config.summary_dir]\n [make_dir(d) for d in dir_list]\n\n # Prepare model inputs\n train_data = os.path.join(config.tfrecord_dir, 'train.tfrecords')\n validation_data = os.path.join(config.tfrecord_dir, 'val.tfrecords')\n feat_mean = 0 # np.mean(np.load(config.mean_file)['feat_list'])\n\n # Prepare data on CPU\n with tf.device('/cpu:0'):\n train_images, train_labels = inputs(\n tfrecord_file=train_data,\n batch_size=config.train_batch,\n num_feats=config.n_features,\n sample=config.sample['train'],\n max_pixels_per_image=config.max_pixels_per_image,\n im_size=config.resize,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n num_epochs=config.epochs,\n feat_mean_value=feat_mean)\n val_images, val_labels = inputs(\n tfrecord_file=validation_data,\n batch_size=1,\n num_feats=config.n_features,\n sample=config.sample['val'],\n max_pixels_per_image=config.max_pixels_per_image,\n im_size=config.resize,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n num_epochs=config.epochs,\n feat_mean_value=feat_mean)\n tf.summary.image('validation images', tf.cast(val_labels, tf.float32))\n\n # Prepare model on GPU\n with tf.device('/gpu:0'):\n with tf.variable_scope('cnn') as scope:\n\n model = model_struct()\n train_mode = tf.get_variable(name='training', initializer=True)\n model.build(\n features=train_images,\n output_categories=len(config.labels.keys()),\n train_mode=train_mode, batchnorm=config.batch_norm)\n\n # Prepare the cost function\n cost = softmax_cost(\n model.res_logits, train_labels, ratio=config.ratio,\n label_reshape=[\n config.batch_size * config.max_pixels_per_image])\n train_op = tf.train.AdamOptimizer(config.lr).minimize(cost)\n\n tf.summary.scalar(\"cost\", cost)\n\n train_score = correlation(\n model.prob, train_labels) # training accuracy\n tf.summary.scalar(\"training correlation\", train_score)\n\n # Setup validation op\n if validation_data is not False:\n scope.reuse_variables()\n # Validation graph is the same as training except no batchnorm\n val_model = model_struct()\n val_model.build(\n features=val_images,\n output_categories=len(config.labels.keys()))\n\n # Calculate validation accuracy\n val_pred = tf.cast(\n tf.reshape(\n tf.argmax(\n val_model.prob, axis=1),\n [1, config.resize[0], config.resize[1], 1]),\n tf.float32)\n tf.summary.image('validation prediction', val_pred)\n val_score = correlation(\n val_model.prob, tf.reshape(\n val_labels, [np.prod(config.resize), 1]))\n tf.summary.scalar(\"validation correlation\", val_score)\n\n # Set up summaries and saver\n saver = tf.train.Saver(\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\n summary_op = tf.summary.merge_all()\n\n # Initialize the graph\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\n\n # Need to initialize both of these if supplying num_epochs to inputs\n sess.run(tf.group(tf.global_variables_initializer(),\n tf.local_variables_initializer()))\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\n\n # Set up exemplar threading\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n\n # Start training loop\n np.save(config.train_checkpoint, config)\n step, val_max, losses = 0, 0, []\n train_acc = 0\n try:\n while not coord.should_stop():\n start_time = time.time()\n _, loss_value, train_acc = sess.run([train_op, cost, train_score])\n losses.append(loss_value)\n duration = time.time() - start_time\n assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\n\n if step % 100 == 0 and step % 10 == 0:\n if validation_data is not False:\n _, val_acc, val_frame = sess.run(\n [train_op, val_score, val_pred])\n\n np.save(\n os.path.join(\n config.model_output, '%s_val_image' % step),\n val_frame)\n else:\n val_acc = -1 # Store every checkpoint\n\n # Summaries\n summary_str = sess.run(summary_op)\n summary_writer.add_summary(summary_str, step)\n\n # Training status and validation accuracy\n format_str = (\n '%s: step %d, loss = %.2f (%.1f examples/sec; '\n '%.3f sec/batch) | Training r = %s | '\n 'Validation r = %s | logdir = %s')\n print (format_str % (\n datetime.now(), step, loss_value,\n config.train_batch / duration, float(duration),\n train_acc, val_acc, config.summary_dir))\n\n # Save the model checkpoint if it's the best yet\n if val_acc > val_max:\n saver.save(\n sess, os.path.join(\n config.train_checkpoint,\n 'model_' + str(step) + '.ckpt'), global_step=step)\n\n # Store the new max validation accuracy\n val_max = val_acc\n\n else:\n # Training status\n format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; '\n '%.3f sec/batch) | Training F = %s')\n print (format_str % (datetime.now(), step, loss_value,\n config.train_batch / duration,\n float(duration), train_acc))\n # End iteration\n step += 1\n\n except tf.errors.OutOfRangeError:\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\n finally:\n coord.request_stop()\n\n dt_stamp = get_dt() # date-time stamp\n np.save(\n os.path.join(\n config.tfrecord_dir, '%straining_loss' % dt_stamp), losses)\n coord.join(threads)\n sess.close()","def load_pretrained_model(self,model_dir):\n rnn_params = json.load(open(os.path.join(model_dir,\n \"./model.json\")))[\"rnn\"]\n\n logging.info(\"Loading model from: {}\".format(model_dir))\n self.create_training_model(model_dir = model_dir,\n **rnn_params)\n #从目录中读取神经网络参数\n self.set_model_from_file()","def checkpoint_model(PATH, ckpt_id, model, epoch, last_global_step,\r\n last_global_data_samples, **kwargs):\r\n checkpoint_state_dict = {\r\n 'epoch': epoch,\r\n 'last_global_step': last_global_step,\r\n 'last_global_data_samples': last_global_data_samples\r\n }\r\n # Add extra kwargs too\r\n checkpoint_state_dict.update(kwargs)\r\n\r\n success = model.network.save_checkpoint(PATH, ckpt_id,\r\n checkpoint_state_dict)\r\n status_msg = 'checkpointing: PATH={}, ckpt_id={}'.format(PATH, ckpt_id)\r\n if success:\r\n logging.info(f\"Success {status_msg}\")\r\n else:\r\n logging.warning(f\"Failure {status_msg}\")\r\n return","def save_model(self, checkpoint_path, epoch):\n self.saver.save(self.sess, checkpoint_path, global_step = epoch)","def build_graph_from_config(self, model_config, track_config, checkpoint_path):\n self.build_model()\n \n ema = tf.train.ExponentialMovingAverage(0)\n variables_to_restore = ema.variables_to_restore(moving_avg_variables=[])\n\n # Filter out State variables\n variables_to_restore_filterd = {}\n for key, value in variables_to_restore.items():\n if key.split('/')[1] != 'State':\n if \"alex_branch\" not in key:\n if \"vggf_branch\" not in key:\n variables_to_restore_filterd[key] = value\n \n saver = tf.train.Saver(variables_to_restore_filterd)\n \n\n if osp.isdir(checkpoint_path):\n #checkpoint_path = tf.train.latest_checkpoint(checkpoint_path)\n if not checkpoint_path:\n raise ValueError(\"No checkpoint file found in: {}\".format(checkpoint_path))\n\n def _restore_fn(sess):\n logging.info(\"Loading model from checkpoint: %s\", checkpoint_path)\n saver.restore(sess, checkpoint_path)\n logging.info(\"Successfully loaded checkpoint: %s\", os.path.basename(checkpoint_path))\n logging.info(\"Restore CANet...\")\n\n return _restore_fn","def load_model(self, model_path):\n # Check the model file exists\n if not os.path.isfile(model_path):\n raise ValueError(f\"The model file `{model_path}` is not exists or broken!\")\n\n checkpoint = torch.load(model_path)\n self.model_type = checkpoint['model_type']\n self.label2idx = checkpoint['label2idx']\n self.idx2label = checkpoint['idx2label']\n self.model.load_state_dict(checkpoint['model_state_dict'])\n self.model.to(self.device)","def load_training_checkpoint(args, model, PATH, ckpt_id):\r\n logger = args.logger\r\n _, checkpoint_state_dict = model.network.load_checkpoint(PATH, ckpt_id)\r\n epoch = checkpoint_state_dict['epoch']\r\n last_global_step = checkpoint_state_dict['last_global_step']\r\n last_global_data_samples = checkpoint_state_dict[\r\n 'last_global_data_samples']\r\n del checkpoint_state_dict\r\n return (epoch, last_global_step, last_global_data_samples)","def __init__(self, saved_model=None, serialize_input=True):\n assert saved_model\n self.saved_model_path = saved_model\n self.serialize_input = serialize_input\n logging.info(\"Reading checkpoint {}.\".format(saved_model))\n imported_model = tf.saved_model.load(saved_model)\n self.bleurt_model_ops = imported_model.signatures[\"serving_default\"]\n logging.info(\"BLEURT initialized.\")","def load_checkpoint(checkpoint_path, model, optimizer=None):\n if not os.path.exists(checkpoint_path):\n raise IOError(f\"Checkpoint '{checkpoint_path}' does not exist\")\n\n state = torch.load(checkpoint_path)\n try:\n model.load_state_dict(state['model_state_dict'])\n except BaseException as e:\n print('Failed to do something: ' + str(e))\n\n if optimizer is not None:\n try:\n optimizer.load_state_dict(state['optimizer_state_dict'])\n except Exception as e:\n print(e)\n\n return state","def _init_model(\n self,\n cfg: ConfigType,\n weights: Optional[str],\n device: str = 'cpu',\n ) -> nn.Module:\n checkpoint: Optional[dict] = None\n if weights is not None:\n checkpoint = _load_checkpoint(weights, map_location='cpu')\n\n if not cfg:\n assert checkpoint is not None\n try:\n # Prefer to get config from `message_hub` since `message_hub`\n # is a more stable module to store all runtime information.\n # However, the early version of MMEngine will not save config\n # in `message_hub`, so we will try to load config from `meta`.\n cfg_string = checkpoint['message_hub']['runtime_info']['cfg']\n except KeyError:\n assert 'meta' in checkpoint, (\n 'If model(config) is not provided, the checkpoint must'\n 'contain the config string in `meta` or `message_hub`, '\n 'but both `meta` and `message_hub` are not found in the '\n 'checkpoint.')\n meta = checkpoint['meta']\n if 'cfg' in meta:\n cfg_string = meta['cfg']\n else:\n raise ValueError(\n 'Cannot find the config in the checkpoint.')\n cfg.update(\n Config.fromstring(cfg_string, file_format='.py')._cfg_dict)\n\n # Delete the `pretrained` field to prevent model from loading the\n # the pretrained weights unnecessarily.\n if cfg.model.get('pretrained') is not None:\n del cfg.model.pretrained\n\n model = MODELS.build(cfg.model)\n model.cfg = cfg\n self._load_weights_to_model(model, checkpoint, cfg)\n model.to(device)\n model.eval()\n return model","def load(self, checkpoint_dir):\n print(\"\\nReading Checkpoints.....\\n\\n\")\n model_dir = \"%s\" % (\"cnn\") # give the model name by label_size\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir)\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\n \n # Check the checkpoint is exist\n if ckpt and ckpt.model_checkpoint_path:\n ckpt_path = str(ckpt.model_checkpoint_path) # convert the unicode to string\n self.saver.restore(self.sess, os.path.join(os.getcwd(), ckpt_path))\n print(\"\\n Checkpoint Loading Success! %s\\n\\n\"% ckpt_path)\n else:\n print(\"\\n! Checkpoint Loading Failed \\n\\n\")","def load_model(path='./model_checkpoint', name='tf_model'):\n with open(os.path.join(path, name + '.json')) as json_file:\n json_config = json_file.read()\n model = TensorModel(tf.keras.models.model_from_json(json_config))\n model._model.load_weights(os.path.join(path, name + '_weights.h5'))\n\n return model","def try_create_model_load_from_checkpoint_and_adjust(self) -> bool:\n success = self.try_create_model_and_load_from_checkpoint()\n self.create_summary_and_adjust_model_for_gpus()\n return success","def load_model_from_checkpoint(file, device):\r\n\r\n if device == 'cuda':\r\n # Load all tensors onto GPU\r\n map_location = lambda storage, loc: storage.cuda()\r\n else:\r\n # Load all tensors onto CPU\r\n map_location = lambda storage, loc: storage\r\n\r\n # Assuming model was trained and checkpoint saved on Linux, but predict.py inference is executed using Windows.\r\n # Then, it is required to implement the following quick fix, because otherwise the exception is raised:\r\n # \"NotImplementedError: cannot instantiate 'PosixPath' on your system\"\r\n # Credits to https://stackoverflow.com/questions/57286486/i-cant-load-my-model-because-i-cant-put-a-posixpath\r\n if type(file) == pathlib.WindowsPath:\r\n tmp_PosixPath = pathlib.PosixPath\r\n pathlib.PosixPath = pathlib.WindowsPath\r\n\r\n parameters = torch.load(file, map_location=map_location)\r\n\r\n # Restore default\r\n if type(file) == pathlib.WindowsPath:\r\n pathlib.WindowsPath = pathlib.PosixPath\r\n pathlib.PosixPath = tmp_PosixPath\r\n\r\n model = train.create_model(parameters)\r\n\r\n model.class_to_idx = parameters.get('train_datasets_class_to_idx')\r\n model.load_state_dict(parameters.get('state_dict'), strict=False)\r\n\r\n return model, parameters","def create_checkpoint(self, name, path=''):\n\n\t\tnb_path = self._get_os_path(name, path)\n\t\tself.log.debug('creating checkpoint \"%s\" \"%s\" \"%s\"' % (path, name, nb_path))\n\t\t# only the one checkpoint ID:\n\t\tcheckpoint_id = u\"checkpoint\"\n\t\tcp_path = self.get_checkpoint_path(checkpoint_id, name, path)\n\t\tself.log.debug(\"creating checkpoint for notebook %s\", name)\n\t\tif not key_exists(self.bucket, self.checkpoint_dir):\n\t\t\tnew_key_from_string(self.bucket, self.checkpoint_dir, '')\n\t\tself._copy(nb_path, cp_path)\n\n\t\t# return the checkpoint info\n\t\treturn self.get_checkpoint_model(checkpoint_id, name, path)","def load_checkpoint(checkpoint_path, model, optimizer=None):\n if not os.path.exists(checkpoint_path):\n raise IOError(\"Checkpoint '{}' does not exist\".format(checkpoint_path))\n\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else 'cpu')\n state = torch.load(checkpoint_path, map_location=\"cuda:0\")\n model.load_state_dict(state['model_state_dict'])\n\n if optimizer is not None:\n optimizer.load_state_dict(state['optimizer_state_dict'])\n\n return state","def create_model(self):\n try:\n self.model = PPO2.load(self.save_path)\n self.model.set_env(self.env)\n print(\"Loading of the latest model successful!\")\n except:\n print(\"Creating new model...\")\n self.model = PPO2(CnnPolicy, self.env, verbose=1)","def _restore_checkpoint(self, checkpoint_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(checkpoint_path))\n checkpoint = torch.load(checkpoint_path)\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\n \n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\n print('Parameters are inconsistant, adapting model parameters ...')\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\n del pretrained_dict['1']\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\n self.model.load_state_dict(model_dict)\n else:\n print('Parameters are consistant, load state dict directly ...')\n self.model.load_state_dict(checkpoint['state_dict'])\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\n # if self.with_cuda:\n # for state in self.optimizer.state.values():\n # for k, v in state.items():\n # if isinstance(v, torch.Tensor):\n # state[k] = v.cuda(self.device)","def load_model(config, batchmanager):\n \n # this function returns a dictionary mapping\n # name of the task (string) --> number of classes in the task (int)\n tasks = batchmanager.getTasksWithNClasses()\n # this \"tasks\" object is used to initialize the model (with the right output layers)\n model = MultiTaskBERT(device = config.device, tasks = tasks)\n\n if not config.untrained_baseline:\n\n # if we evaluate only, model MUST be loaded.\n if config.k_shot_only:\n try :\n model.load_state_dict(torch.load(path_to_dicts(config), map_location = config.device))\n except Exception:\n print(f\"WARNING: the `--k_shot_only` flag was passed, but `{path_to_dicts(config)}` was NOT found!\")\n raise Exception()\n \n # if we saved the state dictionary, load it.\n elif config.resume:\n try :\n model.load_state_dict(torch.load(path_to_dicts(config), map_location = config.device))\n except Exception:\n print(f\"WARNING: the `--resume` flag was passed, but `{path_to_dicts(config)}` was NOT found!\")\n else:\n if os.path.exists(path_to_dicts(config)):\n print(f\"WARNING: `--resume` flag was NOT passed, but `{path_to_dicts(config)}` was found!\") \n\n return model","def load_checkpoints(args, model): \n print('Loading the model checkpoints from iter {}...'.format(args.resume_iter))\n checkpoint_path = os.path.join(config.checkpoint_path, args.model_type)\n\n gen_g_path = os.path.join(checkpoint_path, '{}-Gen_g.ckpt'.format(args.resume_iter))\n gen_f_path = os.path.join(checkpoint_path, '{}-Gen_f.ckpt'.format(args.resume_iter))\n model.gen_g.load_state_dict(torch.load(gen_g_path, map_location=lambda storage, loc: storage))\n model.gen_f.load_state_dict(torch.load(gen_f_path, map_location=lambda storage, loc: storage))\n\n if args.train:\n dis_c_path = os.path.join(checkpoint_path, '{}-Dis_c.ckpt'.format(args.resume_iter))\n dis_t_path = os.path.join(checkpoint_path, '{}-Dis_t.ckpt'.format(args.resume_iter))\n model.dis_c.load_state_dict(torch.load(dis_c_path, map_location=lambda storage, loc: storage))\n model.dis_t.load_state_dict(torch.load(dis_t_path, map_location=lambda storage, loc: storage))","def train(model_name, batch_size, steps_per_epoch, epochs, validation_steps, \n model_file=None, save_path=None):\n \n print(\"- Loading configuration...\")\n if model_name in models_default_params:\n default_params = models_default_params[model_name]\n else:\n print(\"Error: the model '{}' has not been implemented\".format(model_name))\n return\n custom_objects = default_params['custom_objects']\n patch_size = default_params['patch_size']\n if save_path is None:\n save_path = default_params['default_path']\n if os.path.isfile(save_path):\n print(\"Warning: {} is an existing file and will be overwritten.\".format(save_path))\n print(\"- Configuration loaded.\")\n \n print(\"- Loading datasets...\")\n train_gen = preprocess.load_dataset(batch_size, x_directory = \"datasets/Potsdam/Training/RGB/\",\n y_directory = \"datasets/Potsdam/Training/Labels/\",\n patch_size = patch_size)\n val_gen = preprocess.load_dataset(batch_size, x_directory = \"datasets/Potsdam/Validation/RGB/\",\n y_directory = \"datasets/Potsdam/Validation/Labels/\",\n patch_size = patch_size)\n print(\"- Data loaded.\")\n \n print(\"- Initialising model...\")\n if(model_file is not None): # Further train existing model\n model = keras.models.load_model(model_file, custom_objects=custom_objects)\n else: # Create new model\n if model_name == 'fcn':\n model = fcn.make_fcn_resnet((patch_size, patch_size, channels), nb_labels, \n use_pretraining=False, freeze_base=False)\n elif model_name == 'pspnet':\n model = pspnet.build_pspnet(nb_classes=nb_labels, resnet_layers=50,\n input_shape=patch_size)\n elif model_name == 'mobilenetv2':\n model = mobilenetv2.MobileNetv2((patch_size, patch_size, channels), nb_labels) \n\n model.compile(\n optimizer = optimizers.Adam(lr = 0.00001),\n loss = losses.categorical_crossentropy,\n metrics = [metrics.categorical_accuracy]) \n model.summary() \n print(\"- Model initialised.\")\n \n tensorboard = callbacks.TensorBoard(log_dir='./logs')\n csv_logger = callbacks.CSVLogger('logs/training.csv')\n checkpoint = callbacks.ModelCheckpoint(filepath=checkpoint_path,\n save_weights_only=True,\n save_best_only=True)\n \n print(\"- Starting training.\")\n model.fit_generator(\n generator=train_gen,\n steps_per_epoch=steps_per_epoch,\n epochs=epochs,\n validation_data=val_gen,\n validation_steps=validation_steps,\n # callbacks=[checkpoint, csv_logger]\n )\n print(\"- Training complete.\")\n \n model.save(save_path)\n print(\"- Model saved to {}\".format(save_path))","def _setup_training(self, params, **kwargs):\n model_params = params.permute_training_on_top().model\n\n model_kwargs = {**model_params.fixed, **model_params.variable}\n\n model = self.model_cls(**model_kwargs)\n\n training_params = params.permute_training_on_top().training\n losses = training_params.nested_get(\"losses\")\n optimizer_cls = training_params.nested_get(\"optimizer_cls\")\n optimizer_params = training_params.nested_get(\"optimizer_params\")\n train_metrics = training_params.nested_get(\"train_metrics\", {})\n lr_scheduler_cls = training_params.nested_get(\"lr_sched_cls\", None)\n lr_scheduler_params = training_params.nested_get(\"lr_sched_params\",\n {})\n val_metrics = training_params.nested_get(\"val_metrics\", {})\n\n # necessary for resuming training from a given path\n save_path = kwargs.pop(\"save_path\", os.path.join(\n self.save_path,\n \"checkpoints\",\n \"run_%02d\" % self._run))\n\n return self.trainer_cls(\n network=model,\n save_path=save_path,\n losses=losses,\n key_mapping=self.key_mapping,\n optimizer_cls=optimizer_cls,\n optimizer_params=optimizer_params,\n train_metrics=train_metrics,\n val_metrics=val_metrics,\n lr_scheduler_cls=lr_scheduler_cls,\n lr_scheduler_params=lr_scheduler_params,\n optim_fn=self._optim_builder,\n save_freq=self.checkpoint_freq,\n **kwargs\n )","def load(self):\n try:\n if self.model.is_cuda:\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \"save_point.pth\")))\n else:\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \\\n \"save_point.pth\"), map_location=\"cpu\"))\n except:\n sys.exit(\"Unable to load previous model\")","def train_and_eval(config, babas_data):\n\n if config.resume_from_checkpoint is not None:\n try:\n if config.augment_background == 'background':\n bg = config.augment_background\n else:\n bg = None\n rfc = config.resume_from_checkpoint\n ic = config.include_validation\n print 'Loading saved config: %s' % config.saved_config\n config = np.load(config.saved_config).item()\n config.resume_from_checkpoint = rfc\n config.include_validation = ic\n if not hasattr(config, 'augment_background'):\n config.augment_background = 'constant'\n if not hasattr(config, 'background_folder'):\n config.background_folder = 'backgrounds'\n if bg is not None:\n print 'Overriding saved config to add kinect backgrounds to training.'\n config.augment_background = bg\n results_dir = rfc\n except:\n print 'Relying on default config file.'\n\n if babas_data: # Shitty naive training method\n config.tfrecord_dir = '/media/data_cifs/monkey_tracking/data_for_babas/tfrecords_from_babas'\n config.babas_tfrecord_dir = config.tfrecord_dir\n config.steps_before_validation = 20\n config.epochs = 2000\n config.convert_labels_to_pixel_space = False\n config.augment_background = 'constant'\n\n # Import your model\n print 'Model directory: %s' % config.model_output\n print 'Running model: %s' % config.model_type\n model_file = import_cnn(config.model_type)\n\n # Prepare model training\n dt_stamp = re.split(\n '\\.', str(datetime.now()))[0].\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\n dt_dataset = '%s_%s' % (config.model_type, dt_stamp)\n if config.selected_joints is not None:\n dt_dataset = '_%s' % (config.selected_joints) + dt_dataset\n config.train_checkpoint = os.path.join(\n config.model_output, dt_dataset) # timestamp this run\n config.summary_dir = os.path.join(\n config.train_summaries, dt_dataset)\n results_dir = os.path.join(config.npy_dir, dt_dataset)\n print 'Saving Dmurphy\\'s online updates to: %s' % results_dir\n dir_list = [config.train_checkpoint, config.summary_dir, results_dir]\n [tf_fun.make_dir(d) for d in dir_list]\n\n # Prepare model inputs\n train_data = os.path.join(config.tfrecord_dir, config.train_tfrecords)\n if config.babas_tfrecord_dir is not None:\n train_babas_tfrecord_dir = os.path.join(\n config.babas_tfrecord_dir,\n config.train_tfrecords)\n if config.include_validation or config.include_validation is None:\n val_babas_tfrecord_dir = os.path.join(\n config.babas_tfrecord_dir,\n config.val_tfrecords)\n else:\n train_babas_tfrecord_dir = None\n val_babas_tfrecord_dir = None\n\n if isinstance(config.include_validation, basestring):\n validation_data = config.include_validation\n elif config.include_validation == True:\n validation_data = os.path.join(\n config.tfrecord_dir,\n config.val_tfrecords)\n else:\n validation_data = None\n\n print 'Using training set: %s' % train_data\n print 'Using validation set: %s' % validation_data\n\n # Prepare data on CPU\n with tf.device('/cpu:0'):\n train_data_dict = inputs(\n tfrecord_file=train_data,\n batch_size=config.train_batch,\n im_size=config.resize,\n target_size=config.image_target_size,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n label_shape=config.num_classes,\n num_epochs=config.epochs,\n image_target_size=config.image_target_size,\n image_input_size=config.image_input_size,\n maya_conversion=config.maya_conversion,\n max_value=config.max_depth,\n normalize_labels=config.normalize_labels,\n aux_losses=config.aux_losses,\n selected_joints=config.selected_joints,\n joint_names=config.joint_order,\n num_dims=config.num_dims,\n keep_dims=config.keep_dims,\n mask_occluded_joints=config.mask_occluded_joints,\n background_multiplier=config.background_multiplier,\n augment_background=config.augment_background,\n background_folder=config.background_folder,\n randomize_background=config.randomize_background,\n maya_joint_labels=config.labels,\n babas_tfrecord_dir=train_babas_tfrecord_dir,\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\n image_target_size_is_flipped=config.image_target_size_is_flipped)\n train_data_dict['deconv_label_size'] = len(config.labels)\n\n val_data_dict = inputs(\n tfrecord_file=validation_data,\n batch_size=config.validation_batch,\n im_size=config.resize,\n target_size=config.image_target_size,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n label_shape=config.num_classes,\n num_epochs=config.epochs,\n image_target_size=config.image_target_size,\n image_input_size=config.image_input_size,\n maya_conversion=config.maya_conversion,\n max_value=config.max_depth,\n normalize_labels=config.normalize_labels,\n aux_losses=config.aux_losses,\n selected_joints=config.selected_joints,\n joint_names=config.joint_order,\n num_dims=config.num_dims,\n keep_dims=config.keep_dims,\n mask_occluded_joints=config.mask_occluded_joints,\n background_multiplier=config.background_multiplier,\n augment_background='none',\n background_folder=config.background_folder,\n randomize_background=None,\n maya_joint_labels=config.labels,\n babas_tfrecord_dir=val_babas_tfrecord_dir,\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\n image_target_size_is_flipped=config.image_target_size_is_flipped)\n val_data_dict['deconv_label_size'] = len(config.labels)\n\n # Check output_shape\n if config.selected_joints is not None:\n print 'Targeting joint: %s' % config.selected_joints\n joint_shape = len(config.selected_joints) * config.keep_dims\n if (config.num_classes // config.keep_dims) > (joint_shape):\n print 'New target size: %s' % joint_shape\n config.num_classes = joint_shape\n\n with tf.device('/gpu:0'):\n with tf.variable_scope('cnn') as scope:\n print 'Creating training graph:'\n model = model_file.model_struct(\n weight_npy_path=config.weight_npy_path)\n train_mode = tf.get_variable(name='training', initializer=True)\n model.build(\n rgb=train_data_dict['image'],\n target_variables=train_data_dict,\n train_mode=train_mode,\n batchnorm=config.batch_norm)\n train_mu, train_var = tf.nn.moments(train_data_dict['image'], axes=[1, 2, 3])\n tf.summary.histogram(\"train image mean\", train_mu)\n tf.summary.histogram(\"train image std\", tf.sqrt(train_var))\n if 'deconv_image' in config.aux_losses:\n tf.summary.image('Deconv train', model.deconv)\n if 'deconv_label' in config.aux_losses:\n tf.summary.image(\n 'Deconv label train',\n tf.expand_dims(\n tf.cast(\n tf.argmax(model.deconv, axis=3), tf.float32), 3))\n\n # Setup validation op\n if validation_data is not False:\n scope.reuse_variables()\n print 'Creating validation graph:'\n val_model = model_file.model_struct()\n val_model.build(\n rgb=val_data_dict['image'],\n target_variables=val_data_dict)\n\n # Calculate validation accuracy\n val_mu, val_var = tf.nn.moments(val_data_dict['image'], axes=[1, 2, 3])\n tf.summary.histogram(\"validation image mean\", val_mu)\n tf.summary.histogram(\"validation image std\", tf.sqrt(val_var))\n if 'label' in val_data_dict.keys():\n # val_score = tf.reduce_mean(\n # tf_fun.l2_loss(\n # val_model.output, val_data_dict['label']))\n if config.keep_dims == 3:\n z_mask = tf.expand_dims(tf.tile([1, 1, 0], [int(val_data_dict['label'].get_shape()[-1]) // 3]), axis=0)\n z_mask = tf.cast(z_mask, tf.float32)\n val_model.output = val_model.output * z_mask\n val_data_dict['label'] = val_data_dict['label'] * z_mask \n val_score = tf.reduce_mean(tf.nn.l2_loss(val_model.output - val_data_dict['label']))\n tf.summary.scalar(\"validation mse\", val_score)\n if 'fc' in config.aux_losses:\n tf.summary.image('FC val activations', val_model.final_fc)\n if 'deconv_image' in config.aux_losses:\n tf.summary.image('Deconv val', val_model.deconv)\n if 'deconv_label' in config.aux_losses:\n tf.summary.image(\n 'Deconv label train',\n tf.expand_dims(\n tf.cast(\n tf.argmax(val_model.deconv, axis=3),\n tf.float32), 3))\n tf.summary.image(\n 'validation images',\n tf.cast(val_data_dict['image'], tf.float32))\n\n # Prepare the loss functions:::\n loss_list, loss_label = [], []\n if 'label' in train_data_dict.keys():\n # 1. Joint localization loss\n if config.calculate_per_joint_loss == 'thomas':\n label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\n model=model,\n train_data_dict=train_data_dict,\n config=config,\n y_key='label',\n yhat_key='output')\n loss_list += [label_loss]\n elif config.calculate_per_joint_loss == 'skeleton':\n label_loss = tf_fun.skeleton_loss(\n model=model,\n train_data_dict=train_data_dict,\n config=config,\n y_key='label',\n yhat_key='output')\n loss_list += [label_loss]\n elif config.calculate_per_joint_loss == 'skeleton and joint':\n label_loss = tf_fun.skeleton_loss(\n model=model,\n train_data_dict=train_data_dict,\n config=config,\n y_key='label',\n yhat_key='output')\n loss_list += [label_loss]\n loss_label += ['skeleton loss']\n delta = model['output'] - train_data_dict['label']\n proc_weights = np.asarray(\n config.dim_weight)[None,:].repeat(\n len(config.joint_names), axis=0).reshape(1, -1)\n delta *= proc_weights\n # label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\n # model=model,\n # train_data_dict=train_data_dict,\n # config=config,\n # y_key='label',\n # yhat_key='output')\n # loss_list += [label_loss]\n loss_list += [tf.nn.l2_loss(\n model['output'] - train_data_dict['label'])]\n else:\n loss_list += [tf.nn.l2_loss(\n model['output'] - train_data_dict['label'])]\n loss_label += ['combined head']\n for al in loss_helper.potential_aux_losses():\n loss_list, loss_label = loss_helper.get_aux_losses(\n loss_list=loss_list,\n loss_label=loss_label,\n train_data_dict=train_data_dict,\n model=model,\n aux_loss_dict=al,\n domain_adaptation=train_babas_tfrecord_dir)\n loss = tf.add_n(loss_list)\n\n # Add wd if necessary\n if config.wd_penalty is not None:\n _, l2_wd_layers = tf_fun.fine_tune_prepare_layers(\n tf.trainable_variables(), config.wd_layers)\n l2_wd_layers = [\n x for x in l2_wd_layers if 'biases' not in x.name]\n if config.wd_type == 'l1':\n loss += (config.wd_penalty * tf.add_n(\n [tf.reduce_sum(tf.abs(x)) for x in l2_wd_layers]))\n elif config.wd_type == 'l2':\n loss += (config.wd_penalty * tf.add_n(\n [tf.nn.l2_loss(x) for x in l2_wd_layers]))\n\n optimizer = loss_helper.return_optimizer(config.optimizer)\n optimizer = optimizer(config.lr)\n\n if hasattr(config, 'fine_tune_layers') and config.fine_tune_layers is not None:\n print 'Finetuning learning for: %s' % config.fine_tune_layers\n train_op, grads = tf_fun.finetune_learning(\n loss,\n trainables=tf.trainable_variables(),\n fine_tune_layers=config.fine_tune_layers,\n config=config\n )\n else:\n # Op to calculate every variable gradient\n grads = optimizer.compute_gradients(\n loss, tf.trainable_variables())\n # Op to update all variables according to their gradient\n train_op = optimizer.apply_gradients(\n grads_and_vars=grads)\n\n # Summarize all gradients and weights\n [tf.summary.histogram(\n var.name + '/gradient', grad)\n for grad, var in grads if grad is not None]\n # train_op = optimizer.minimize(loss)\n\n # Summarize losses\n [tf.summary.scalar(lab, il) for lab, il in zip(\n loss_label, loss_list)]\n\n # Summarize images and l1 weights\n tf.summary.image(\n 'train images',\n tf.cast(train_data_dict['image'], tf.float32))\n tf_fun.add_filter_summary(\n trainables=tf.trainable_variables(),\n target_layer='conv1_1_filters')\n\n # Set up summaries and saver\n saver = tf.train.Saver(\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\n summary_op = tf.summary.merge_all()\n tf.add_to_collection('output', model.output)\n\n # Initialize the graph\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\n\n # Need to initialize both of these if supplying num_epochs to inputs\n sess.run(tf.group(tf.global_variables_initializer(),\n tf.local_variables_initializer()))\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\n\n # Set up exemplar threading\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n\n # Create list of variables to run through training model\n train_session_vars = {\n 'train_op': train_op,\n 'loss_value': loss,\n 'im': train_data_dict['image'],\n 'yhat': model.output,\n 'ytrue': train_data_dict['label']\n }\n if hasattr(model, 'deconv'):\n train_session_vars['deconv'] = model.deconv\n if hasattr(model, 'final_fc'):\n train_session_vars['fc'] = model.final_fc\n\n # Create list of variables to run through validation model\n val_session_vars = {\n 'val_acc': val_score,\n 'val_pred': val_model.output,\n 'val_ims': val_data_dict['image'],\n 'val_true': val_data_dict['label'],\n }\n\n # Create list of variables to save to numpys\n save_training_vars = [\n 'im',\n 'yhat',\n 'ytrue',\n 'yhat'\n ]\n\n for al in loss_helper.potential_aux_losses():\n if al.keys()[0] in train_data_dict.keys():\n y_key = '%s' % al.keys()[0]\n train_session_vars[y_key] = train_data_dict[al.values()[0]['y_name']]\n save_training_vars += [y_key]\n\n yhat_key = '%s_hat' % al.keys()[0]\n train_session_vars[yhat_key] = model[al.values()[0]['model_name']]\n save_training_vars += [yhat_key]\n\n # Start training loop\n np.save(config.train_checkpoint, config)\n step, losses = 0, []\n num_joints = int(\n train_data_dict['label'].get_shape()[-1]) // config.keep_dims\n normalize_vec = tf_fun.get_normalization_vec(config, num_joints)\n if config.resume_from_checkpoint is not None:\n if '.ckpt' in config.resume_from_checkpoint:\n ckpt = config.resume_from_checkpoint\n 'Restoring specified checkpoint: %s' % config.resume_from_checkpoint\n else:\n ckpt = tf.train.latest_checkpoint(config.resume_from_checkpoint)\n print 'Evaluating checkpoint: %s' % ckpt\n saver.restore(sess, ckpt)\n try:\n while not coord.should_stop():\n start_time = time.time()\n train_out_dict = sess.run(train_session_vars.values())\n train_out_dict = {k: v for k, v in zip(\n train_session_vars.keys(), train_out_dict)}\n losses.append(train_out_dict['loss_value'])\n duration = time.time() - start_time\n assert not np.isnan(\n train_out_dict['loss_value']), 'Model diverged with loss = NaN'\n if step % config.steps_before_validation == 0:\n if validation_data is not False:\n val_out_dict = sess.run(\n val_session_vars.values())\n val_out_dict = {k: v for k, v in zip(\n val_session_vars.keys(), val_out_dict)}\n # if config.normalize_labels:\n # val_out_dict['val_pred'] *= normalize_vec\n # val_out_dict['val_true'] *= normalize_vec\n np.savez(\n os.path.join(\n results_dir, '%s_val_coors' % step),\n val_pred=val_out_dict['val_pred'],\n val_ims=val_out_dict['val_ims'],\n val_true=val_out_dict['val_true'],\n normalize_vec=normalize_vec)\n with open(\n os.path.join(\n results_dir, '%s_config.p' % step), 'wb') as fp:\n pickle.dump(config, fp)\n\n # Summaries\n summary_str = sess.run(summary_op)\n summary_writer.add_summary(summary_str, step)\n\n # Training status and validation accuracy attach 9177\n format_str = (\n '%s: step %d, loss = %.8f (%.1f examples/sec; '\n '%.3f sec/batch) | '\n 'Validation l2 loss = %s | logdir = %s')\n print (format_str % (\n datetime.now(), step, train_out_dict['loss_value'],\n config.train_batch / duration, float(duration),\n val_out_dict['val_acc'],\n config.summary_dir))\n\n # Save the model checkpoint if it's the best yet\n if config.normalize_labels:\n train_out_dict['yhat'] *= normalize_vec\n train_out_dict['ytrue'] *= normalize_vec\n [save_training_data(\n output_dir=results_dir,\n data=train_out_dict[k],\n name='%s_%s' % (k, step)) for k in save_training_vars]\n saver.save(\n sess, os.path.join(\n config.train_checkpoint,\n 'model_' + str(step) + '.ckpt'), global_step=step)\n\n else:\n # Training status\n format_str = ('%s: step %d, loss = %.8f (%.1f examples/sec; '\n '%.3f sec/batch)')\n print (format_str % (\n datetime.now(),\n step,\n train_out_dict['loss_value'],\n config.train_batch / duration,\n float(duration)))\n # End iteration\n step += 1\n\n except tf.errors.OutOfRangeError:\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\n finally:\n coord.request_stop()\n dt_stamp = get_dt() # date-time stamp\n np.save(\n os.path.join(\n config.tfrecord_dir, '%s_training_loss' % dt_stamp), losses)\n coord.join(threads)\n sess.close()","def load_ckp(checkpoint_fpath, model, optimizer, device):\n\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\n model.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n valid_acc = checkpoint['valid_acc'] \n return model, optimizer, checkpoint['epoch'], valid_acc","def load_checkpoint(checkpoint, model, optimizer=None):\n model_state_dict, optimizer_state_dict = torch.load(checkpoint)\n model.load_state_dict(model_state_dict)\n\n if optimizer is not None:\n optimizer.load_state_dict(optimizer_state_dict)","def load_epoch_checkpoint(self, directory, epoch):\n chkpnt = torch.load(directory / f\"chkpnt_epoch{epoch:04d}.pth\")\n self.load_state_dict(chkpnt['model_state_dict'])","def __init__(self, model_dir: str, *args, **kwargs):\n super().__init__(model_dir, *args, **kwargs)\n self.model = FRCRN(*args, **kwargs)\n model_bin_file = os.path.join(model_dir,\n ModelFile.TORCH_MODEL_BIN_FILE)\n if os.path.exists(model_bin_file):\n checkpoint = torch.load(\n model_bin_file, map_location=torch.device('cpu'))\n if isinstance(checkpoint, dict) and 'state_dict' in checkpoint:\n # the new trained model by user is based on FRCRNDecorator\n self.load_state_dict(checkpoint['state_dict'])\n else:\n # The released model on Modelscope is based on FRCRN\n self.model.load_state_dict(checkpoint, strict=False)","def load_checkpoint(self, checkpoint: str, **kwargs) -> None:\n with open(checkpoint, \"rb\") as f:\n state = SafePickle.load(f)\n\n state_id = ray.put(state)\n ray.get([worker.set_state.remote(state_id, **kwargs) for worker in self.remote_workers])","def load_model(self):\n if self.ckpt_flag:\n LOG('Skip Loading Pre-trained Model......')\n else:\n if self.params.pre_trained_from is not None and os.path.exists(self.params.pre_trained_from):\n try:\n LOG('Loading Pre-trained Model at %s' % self.params.pre_trained_from)\n pretrain = torch.load(self.params.pre_trained_from)\n self.network.load_state_dict(pretrain)\n LOG('Pre-trained Model Loaded!')\n except:\n WARNING('Cannot load pre-trained model. Start training......')\n else:\n WARNING('Pre-trained model do not exits. Start training......')","def _load_checkpoint(cls, model: DeviceAwareModule, checkpoint_path: Path,\n key_in_state_dict: str, use_gpu: bool) -> int:\n logging.info(f\"Loading checkpoint {checkpoint_path}\")\n checkpoint = ModelAndInfo.read_checkpoint(checkpoint_path, use_gpu)\n\n try:\n state_dict = checkpoint[key_in_state_dict]\n except KeyError:\n logging.error(f\"Key {key_in_state_dict} not found in checkpoint\")\n return False\n\n if isinstance(model, torch.nn.DataParallel):\n result = model.module.load_state_dict(state_dict, strict=False)\n else:\n result = model.load_state_dict(state_dict, strict=False)\n\n if result.missing_keys:\n logging.warning(f\"Missing keys in model checkpoint: {result.missing_keys}\")\n if result.unexpected_keys:\n logging.warning(f\"Unexpected keys in model checkpoint: {result.unexpected_keys}\")\n\n return checkpoint[ModelAndInfo.EPOCH_KEY]","def setup_training(model, train_loader, valid_loader, hps):\r\n\r\n train_dir = os.path.join(hps.save_root, \"train\")\r\n if not os.path.exists(train_dir): os.makedirs(train_dir)\r\n\r\n if hps.restore_model != 'None':\r\n logger.info(\"[INFO] Restoring %s for training...\", hps.restore_model)\r\n bestmodel_file = os.path.join(train_dir, hps.restore_model)\r\n loader = ModelLoader()\r\n loader.load_pytorch(model, bestmodel_file)\r\n else:\r\n logger.info(\"[INFO] Create new model for training...\")\r\n\r\n run_training(model, train_loader, valid_loader, hps) # this is an infinite loop until interrupted\r","def load_checkpoint(self, model, optimizers):\n self.epoch = get_last_epoch(self.log_path)\n\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\n model.load_state_dict(model_state_dict)\n\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\n for opt_ind in range(len(optimizers)):\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\n\n schedulers = load_sched(optimizers, self.epoch)\n\n return model, optimizers, schedulers","def try_and_init_from(self, path):\n log.info(\"Loading weights from foreign checkpoint {}\".format(path))\n if not os.path.exists(path):\n raise ValueError(\"Checkpoint {} does not exist\".format(path))\n\n chkpt = th.load(path, map_location=th.device(\"cpu\"))\n if \"model\" not in chkpt.keys() or chkpt[\"model\"] is None:\n raise ValueError(\"{} has no model saved\".format(path))\n\n mdl = chkpt[\"model\"]\n for n, p in self.model.named_parameters():\n if n in mdl:\n p2 = mdl[n]\n if p2.shape != p.shape:\n log.warning(\"Parameter {} ignored, checkpoint size does not match: {}, should be {}\".format(n, p2.shape, p.shape))\n continue\n log.debug(\"Parameter {} copied\".format(n))\n p.data.copy_(p2)\n else:\n log.warning(\"Parameter {} ignored, not found in source checkpoint.\".format(n))\n\n log.info(\"Weights loaded from foreign checkpoint {}\".format(path))","def _save_model(self, checkpoint_dir):\n # Check whether the specified path exists or not\n isExist = os.path.exists(checkpoint_dir)\n\n if not isExist:\n # Create a new directory because it does not exist\n os.makedirs(checkpoint_dir)\n\n filename = self._get_checkpoint_name()\n path = checkpoint_dir + filename\n\n # Serialize the model checkpoint in to a Python Pickle file\n with open(path, 'wb') as f:\n pickle.dump(self._model, f)\n return path"],"string":"[\n \"def create_checkpoint(model_config, path):\\n model = models.VisionTransformer(num_classes=1, **model_config)\\n variables = model.init(\\n jax.random.PRNGKey(0),\\n jnp.ones([1, 16, 16, 3], jnp.float32),\\n train=False,\\n )\\n _save(variables['params'], path)\",\n \"def load_model(self, checkpoint):\\n print(f'Load parameters from {checkpoint}')\\n epoch = re.match(r\\\"[0-9]*\\\", os.path.basename(checkpoint)).group(0)\\n self.epoch_i = int(epoch)\\n self.model.load_state_dict(torch.load(checkpoint))\",\n \"def load(self, model_path):\\n # TODO: include new params based on ConfigEnum\\n checkpoint = torch.load(model_path)\\n\\n self.image_size = checkpoint['image_size']\\n self.device = checkpoint['device']\\n self.fp16 = checkpoint['fp16']\\n self.accumulate_grad_steps = checkpoint['accumulate_grad_steps']\\n self.experiment_id = checkpoint['experiment_id']\\n self.experiment_tag = checkpoint['experiment_tag']\\n self.seed = checkpoint['seed']\\n self.train_batch_size = checkpoint['train_batch_size']\\n self.valid_batch_size = checkpoint['valid_batch_size']\\n self.test_batch_size = checkpoint['test_batch_size']\\n self.dataloader_num_workers = checkpoint['dataloader_num_workers']\\n self.train_dataloader_shuffle = checkpoint['train_dataloader_shuffle']\\n self.optimizer_type = checkpoint['optimizer_type']\\n self.optimizer_params = checkpoint['optimizer_params']\\n self.scheduler_type = checkpoint['scheduler_type']\\n self.scheduler_params = checkpoint['scheduler_params']\\n self.step_scheduler_after = checkpoint['step_scheduler_after']\\n self.step_scheduler_metric = checkpoint['step_scheduler_metric']\\n self.compute_train_loss_after = checkpoint['compute_train_loss_after']\\n self.compute_train_metric_after = checkpoint['compute_train_metric_after']\\n self.compute_valid_loss_after = checkpoint['compute_valid_loss_after']\\n self.compute_valid_metric_after = checkpoint['compute_valid_metric_after']\\n self.training_stopping_criteria = checkpoint['training_stopping_criteria']\\n self.stopping_criteria_params = checkpoint['stopping_criteria_params']\\n self.max_epoch = checkpoint['max_epoch']\\n self.train_on_all_data = checkpoint['train_on_all_data']\\n self.validate_after = checkpoint['validate_after']\\n self.validation_steps = checkpoint['validation_steps']\\n self.run_lr_range_test= checkpoint['run_lr_range_test']\\n self.sleep_in_epochs = checkpoint['sleep_in_epochs']\\n self.sleep_time = checkpoint['sleep_time']\\n self.checkpoint_epochs = checkpoint['checkpoint_epochs']\\n\\n self._best_score = checkpoint['_best_score']\\n self._current_score = checkpoint['_current_score']\\n self._counter = checkpoint['_counter']\\n self.metrics = checkpoint['metrics']\\n self.current_epoch = checkpoint['current_epoch']\\n self.current_train_batch = checkpoint['current_train_batch']\\n self.current_valid_batch = checkpoint['current_valid_batch']\\n self.num_train_samples = checkpoint['num_train_samples']\\n self.num_train_iterations = checkpoint['num_train_iterations']\\n self.checkpoint_snapshot = checkpoint['checkpoint_snapshot'] \\n\\n # initialize optimizer, scheduler, and gradient scaler\\n self.configure_optimizers()\\n self.configure_schedulers()\\n \\n if self.fp16:\\n self.scaler = torch.cuda.amp.GradScaler()\\n\\n if self.model:\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.model.to(self.device)\\n\\n if self.optimizer:\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n if self.scheduler:\\n self.scheduler.load_state_dict(checkpoint['scheduler'])\\n\\n #if self.scaler:\\n # self.scaler.load_state_dict(checkpoint['scaler'])\",\n \"def init_model(config, program, exe):\\n checkpoints = config['Global'].get('checkpoints')\\n if checkpoints:\\n if os.path.exists(checkpoints + '.pdparams'):\\n path = checkpoints\\n fluid.load(program, path, exe)\\n logger.info(\\\"Finish initing model from {}\\\".format(path))\\n else:\\n raise ValueError(\\\"Model checkpoints {} does not exists,\\\"\\n \\\"check if you lost the file prefix.\\\".format(\\n checkpoints + '.pdparams'))\\n else:\\n pretrain_weights = config['Global'].get('pretrain_weights')\\n if pretrain_weights:\\n path = pretrain_weights\\n load_params(exe, program, path)\\n logger.info(\\\"Finish initing model from {}\\\".format(path))\",\n \"def save_checkpoint(self, model_path=None):\\n # TODO: include new params based on ConfigEnum\\n if not os.path.isdir(path_checkpoints_dir):\\n os.mkdir(path_checkpoints_dir)\\n if model_path is None:\\n model_path = os.path.join(path_checkpoints_dir, f\\\"{self.experiment_id}.pth\\\")\\n print(f\\\"saved the model at {model_path}\\\") \\n model_state_dict = self.model.state_dict()\\n if self.optimizer is not None:\\n opt_state_dict = self.optimizer.state_dict()\\n else:\\n opt_state_dict = None\\n if self.scheduler is not None:\\n sch_state_dict = self.scheduler.state_dict()\\n else:\\n sch_state_dict = None\\n \\n if self.scaler is not None:\\n amp_grad_scaler = self.scaler.state_dict()\\n else:\\n amp_grad_scaler = None\\n\\n model_dict = {}\\n model_dict[\\\"state_dict\\\"] = model_state_dict\\n model_dict[\\\"optimizer\\\"] = opt_state_dict\\n model_dict[\\\"scheduler\\\"] = sch_state_dict\\n model_dict['scaler'] = amp_grad_scaler\\n model_dict['image_size'] = self.image_size\\n model_dict['device'] = self.device\\n model_dict['fp16'] = self.fp16\\n model_dict['accumulate_grad_steps'] = self.accumulate_grad_steps\\n\\n model_dict['experiment_id'] = self.experiment_id\\n model_dict['experiment_tag'] = self.experiment_tag\\n\\n model_dict['seed'] = self.seed\\n\\n model_dict['train_batch_size'] = self.train_batch_size\\n model_dict['valid_batch_size'] = self.valid_batch_size\\n model_dict['test_batch_size'] = self.test_batch_size\\n model_dict['dataloader_num_workers'] = self.dataloader_num_workers\\n model_dict['train_dataloader_shuffle'] = self.train_dataloader_shuffle\\n\\n model_dict['optimizer_type'] = self.optimizer_type\\n model_dict['optimizer_params'] = self.optimizer_params\\n\\n model_dict['scheduler_type'] = self.scheduler_type\\n model_dict['scheduler_params'] = self.scheduler_params\\n model_dict['step_scheduler_after'] = self.step_scheduler_after\\n model_dict['step_scheduler_metric'] = self.step_scheduler_metric\\n\\n model_dict['compute_train_loss_after'] = self.compute_train_loss_after\\n model_dict['compute_train_metric_after'] = self.compute_train_metric_after\\n model_dict['compute_valid_loss_after'] = self.compute_valid_loss_after\\n model_dict['compute_valid_metric_after'] = self.compute_valid_metric_after\\n\\n model_dict['training_stopping_criteria'] = self.training_stopping_criteria\\n model_dict['stopping_criteria_params'] = self.stopping_criteria_params\\n model_dict['max_epoch'] = self.max_epoch\\n model_dict['train_on_all_data'] = self.train_on_all_data\\n model_dict['validate_after'] = self.validate_after\\n model_dict['validation_steps'] = self.validation_steps\\n model_dict['run_lr_range_test'] = self.run_lr_range_test\\n model_dict['sleep_in_epochs'] = self.sleep_in_epochs\\n model_dict['sleep_time'] = self.sleep_time\\n model_dict['checkpoint_epochs'] = self.checkpoint_epochs\\n\\n model_dict['_best_score'] = self._best_score\\n model_dict['_current_score'] = self._current_score\\n model_dict['_counter'] = self._counter\\n\\n model_dict['metrics'] = self.metrics\\n model_dict['current_epoch'] = self.current_epoch\\n model_dict['current_train_batch'] = self.current_train_batch\\n model_dict['current_valid_batch'] = self.current_valid_batch\\n\\n model_dict['num_train_samples'] = self.num_train_samples\\n model_dict['num_train_iterations'] = self.num_train_iterations\\n model_dict['checkpoint_snapshot'] = self.checkpoint_snapshot \\n torch.save(model_dict, model_path)\",\n \"def initialize_model(session, model, train_dir, expect_exists):\\n print \\\"Looking for model at %s...\\\" % train_dir\\n ckpt = tf.train.get_checkpoint_state(train_dir)\\n v2_path = ckpt.model_checkpoint_path + \\\".index\\\" if ckpt else \\\"\\\"\\n if ckpt and (tf.gfile.Exists(ckpt.model_checkpoint_path) or tf.gfile.Exists(v2_path)):\\n print \\\"Reading model parameters from %s\\\" % ckpt.model_checkpoint_path\\n model.saver.restore(session, ckpt.model_checkpoint_path)\\n else:\\n if expect_exists:\\n raise Exception(\\\"There is no saved checkpoint at %s\\\" % train_dir)\\n else:\\n print \\\"There is no saved checkpoint at %s. Creating model with fresh parameters.\\\" % train_dir\\n session.run(tf.global_variables_initializer())\\n print 'Num params: %d' % sum(v.get_shape().num_elements() for v in tf.trainable_variables())\",\n \"def initialize_model(session, model, train_dir, expect_exists):\\n print \\\"Looking for model at %s...\\\" % train_dir\\n ckpt = tf.train.get_checkpoint_state(train_dir)\\n v2_path = ckpt.model_checkpoint_path + \\\".index\\\" if ckpt else \\\"\\\"\\n if ckpt and (tf.gfile.Exists(ckpt.model_checkpoint_path) or tf.gfile.Exists(v2_path)):\\n print \\\"Reading model parameters from %s\\\" % ckpt.model_checkpoint_path\\n model.saver.restore(session, ckpt.model_checkpoint_path)\\n else:\\n if expect_exists:\\n raise Exception(\\\"There is no saved checkpoint at %s\\\" % train_dir)\\n else:\\n print \\\"There is no saved checkpoint at %s. Creating model with fresh parameters.\\\" % train_dir\\n session.run(tf.global_variables_initializer())\\n print 'Num params: %d' % sum(v.get_shape().num_elements() for v in tf.trainable_variables())\",\n \"def load_model(model, checkpoint_path: str): \\r\\n checkpoint = torch.load(checkpoint_path)\\r\\n model.load_state_dict(checkpoint['model'])\\r\\n epoch = checkpoint['epoch']\\r\\n print('Loaded model from {}, epoch {}'.format(checkpoint_path, epoch))\",\n \"def load_model(self, ckpt_fn):\\n checkpoint = torch.load(ckpt_fn)\\n self.net_.load_state_dict(checkpoint[\\\"model\\\"])\\n self.optimizer_.load_state_dict(checkpoint[\\\"optimizer\\\"])\\n self.epoch_ = checkpoint[\\\"epoch\\\"]\\n self.global_step_ = checkpoint[\\\"global_step\\\"]\\n self.model_samples_ = deque(checkpoint[\\\"model_samples\\\"])\\n self.sampler.load_state_dict(checkpoint[\\\"sampler_state\\\"])\\n self.ais_loss.load_state_dict(checkpoint[\\\"ais_state\\\"])\\n self.replay_prob = checkpoint[\\\"replay_prob\\\"]\\n self.max_replay = checkpoint[\\\"max_replay\\\"]\",\n \"def create_or_load_model(model, model_dir, session, name):\\n latest_ckpt = tf.train.latest_checkpoint(model_dir)\\n if latest_ckpt:\\n start_time = time.time()\\n # It only takes a few seconds to initialize all variables.\\n session.run(tf.global_variables_initializer())\\n logging.info(\\n \\\"Initialize %s model with fresh parameters before loading variables \\\"\\n \\\"from the checkpoint, time %.2fs\\\", name,\\n time.time() - start_time)\\n model = load_model(model, latest_ckpt, session, name)\\n else:\\n start_time = time.time()\\n session.run(tf.global_variables_initializer())\\n session.run(tf.tables_initializer())\\n utils.print_out(\\\" created %s model with fresh parameters, time %.2fs\\\" %\\n (name, time.time() - start_time))\\n\\n global_step = model.global_step.eval(session=session)\\n return model, global_step\",\n \"def load_checkpoint(path):\\n\\n # Get the model name\\n model_name = path.split('-')[0]\\n assert (model_name in ['vgg16', 'resnet50'\\n ]), \\\"Path must have the correct model name\\\"\\n\\n # Load in checkpoint\\n checkpoint = torch.load(path)\\n\\n if model_name == 'vgg16':\\n model = models.vgg16(pretrained=True)\\n # Make sure to set parameters as not trainable\\n for param in model.parameters():\\n param.requires_grad = False\\n model.classifier = checkpoint['classifier']\\n\\n elif model_name == 'resnet50':\\n model = models.resnet50(pretrained=True)\\n # Make sure to set parameters as not trainable\\n for param in model.parameters():\\n param.requires_grad = False\\n model.fc = checkpoint['fc']\\n\\n # Load in the state dict\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n total_params = sum(p.numel() for p in model.parameters())\\n print(f'{total_params:,} total parameters.')\\n total_trainable_params = sum(\\n p.numel() for p in model.parameters() if p.requires_grad)\\n print(f'{total_trainable_params:,} total gradient parameters.')\\n\\n # Move to gpu\\n if multi_gpu:\\n model = nn.DataParallel(model)\\n\\n if train_on_gpu:\\n model = model.to('cuda')\\n\\n # Model basics\\n model.class_to_idx = checkpoint['class_to_idx']\\n model.idx_to_class = checkpoint['idx_to_class']\\n model.epochs = checkpoint['epochs']\\n\\n # Optimizer\\n optimizer = checkpoint['optimizer']\\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\n\\n return model, optimizer\",\n \"def load(cls, model_path: str, sample_shape: tuple = None,\\n checkpoint: str = None, **kwargs):\",\n \"def load_checkpoint(tag, params, model):\\r\\n file_name = os.path.join(\\\"saved_models\\\", params.path, tag + \\\".pt\\\")\\r\\n logger.info(\\\"Load checkpoint from %s\\\" % file_name)\\r\\n if os.path.exists(file_name):\\r\\n checkpoint = torch.load(file_name, map_location='cpu')\\r\\n params.training_id = checkpoint['training_id']\\r\\n logger.info(checkpoint['training_id'])\\r\\n model.global_step = checkpoint['global_step']\\r\\n model.load_state_dict(checkpoint['model'])\\r\\n for i, optimizer in enumerate(model.optimizers):\\r\\n optimizer.load_state_dict(checkpoint['optimizers'][i])\\r\\n else:\\r\\n raise Exception(\\\"Checkpoint not found.\\\")\",\n \"def load_checkpoint(filepath):\\n checkpoint = torch.load(filepath)\\n \\n arch = checkpoint['arch']\\n if arch == 'vgg':\\n model = models.vgg16(pretrained=True)\\n elif arch == 'densenet':\\n model = models.densenet121(pretrained=True) \\n \\n model.class_to_idx = checkpoint['class_to_idx']\\n model.classifier = checkpoint['classifier']\\n model.classifier.load_sate_dict = checkpoint['classifier_state_dict']\\n model.optimizer = checkpoint['optimizer_state_dict']\\n model.input_size = checkpoint['input_size']\\n model.output_size = checkpoint['output_size']\\n \\n return model\",\n \"def createModel(config_path, checkpoint_path, graph_path):\\n\\n global build_graph, prev_classes\\n\\n trt_graph = None\\n input_names = None\\n \\n if build_graph:\\n frozen_graph, input_names, output_names = build_detection_graph(\\n config=config_path,\\n checkpoint=checkpoint_path\\n )\\n \\n trt_graph = trt.create_inference_graph(\\n input_graph_def=frozen_graph,\\n outputs=output_names,\\n max_batch_size=1,\\n max_workspace_size_bytes=1 << 25,\\n precision_mode='FP16',\\n minimum_segment_size=50\\n )\\n\\n with open(graph_path, 'wb') as f:\\n f.write(trt_graph.SerializeToString())\\n\\n with open('config.txt', 'r+') as json_file: \\n data = json.load(json_file)\\n data['model'] = []\\n data['model'] = [{'input_names': input_names}]\\n json_file.seek(0)\\n json_file.truncate()\\n json.dump(data, json_file)\\n\\n else:\\n with open(graph_path, 'rb') as f:\\n trt_graph = tf.GraphDef()\\n trt_graph.ParseFromString(f.read())\\n with open('config.txt') as json_file: \\n data = json.load(json_file)\\n input_names = data['model'][0]['input_names']\\n\\n return Model(trt_graph, input_names)\",\n \"def maybe_load_model(name, split_num, checkpoint_dir, resume_from_epoch,\\n batch_norm, l1_factor, l2_factor, optimizer):\\n basename = get_basename(name, split_num)\\n model_filename_fmt = get_model_filename_fmt(basename)\\n model_filename = model_filename_fmt.format(epoch=resume_from_epoch)\\n\\n checkpoint_path = os.path.join(checkpoint_dir, model_filename)\\n\\n if resume_from_epoch > 0 and os.path.isfile(checkpoint_path):\\n\\n click.secho(f\\\"Found model checkpoint '{checkpoint_path}'. \\\"\\n f\\\"Resuming from epoch {resume_from_epoch}.\\\", fg='green')\\n\\n model = load_model(checkpoint_path)\\n\\n initial_epoch = resume_from_epoch\\n\\n else:\\n\\n click.secho(f\\\"Could not load model checkpoint '{checkpoint_path}' \\\"\\n \\\"or `resume_from_epoch == 0`. Building new model.\\\",\\n fg='yellow')\\n\\n model = build_model(output_dim=1, batch_norm=batch_norm,\\n kernel_regularizer=l1_l2(l1_factor, l2_factor))\\n # optimizer = Adam(beta_1=0.5)\\n model.compile(loss='binary_crossentropy', optimizer=optimizer,\\n metrics=['accuracy'])\\n\\n initial_epoch = 0\\n\\n return model, initial_epoch\",\n \"def load_model(self, checkpoint_path):\\n model = self.model_definition()\\n model.load_weights(checkpoint_path)\\n return model\",\n \"def restore_checkpoint(model, checkpoint_dir, cuda=False, force=False, pretrain=False):\\n try:\\n cp_files = [\\n file_\\n for file_ in os.listdir(checkpoint_dir)\\n if file_.startswith(\\\"epoch=\\\") and file_.endswith(\\\".checkpoint.pth.tar\\\")\\n ]\\n except FileNotFoundError:\\n cp_files = None\\n os.makedirs(checkpoint_dir)\\n if not cp_files:\\n print(\\\"No saved model parameters found\\\")\\n if force:\\n raise Exception(\\\"Checkpoint not found\\\")\\n else:\\n return model, 0, []\\n\\n # Find latest epoch\\n for i in itertools.count(1):\\n if \\\"epoch={}.checkpoint.pth.tar\\\".format(i) in cp_files:\\n epoch = i\\n else:\\n break\\n\\n if not force:\\n print(\\n \\\"Which epoch to load from? Choose in range [0, {}].\\\".format(epoch),\\n \\\"Enter 0 to train from scratch.\\\",\\n )\\n print(\\\">> \\\", end=\\\"\\\")\\n inp_epoch = int(input())\\n if inp_epoch not in range(epoch + 1):\\n raise Exception(\\\"Invalid epoch number\\\")\\n if inp_epoch == 0:\\n print(\\\"Checkpoint not loaded\\\")\\n clear_checkpoint(checkpoint_dir)\\n return model, 0, []\\n else:\\n print(\\\"Which epoch to load from? Choose in range [1, {}].\\\".format(epoch))\\n inp_epoch = int(input())\\n if inp_epoch not in range(1, epoch + 1):\\n raise Exception(\\\"Invalid epoch number\\\")\\n\\n filename = os.path.join(\\n checkpoint_dir, \\\"epoch={}.checkpoint.pth.tar\\\".format(inp_epoch)\\n )\\n\\n print(\\\"Loading from checkpoint {}?\\\".format(filename))\\n\\n if cuda:\\n checkpoint = torch.load(filename)\\n else:\\n # Load GPU model on CPU\\n checkpoint = torch.load(filename, map_location=lambda storage, loc: storage)\\n\\n try:\\n start_epoch = checkpoint[\\\"epoch\\\"]\\n stats = checkpoint[\\\"stats\\\"]\\n if pretrain:\\n model.load_state_dict(checkpoint[\\\"state_dict\\\"], strict=False)\\n else:\\n model.load_state_dict(checkpoint[\\\"state_dict\\\"])\\n print(\\n \\\"=> Successfully restored checkpoint (trained for {} epochs)\\\".format(\\n checkpoint[\\\"epoch\\\"]\\n )\\n )\\n except:\\n print(\\\"=> Checkpoint not successfully restored\\\")\\n raise\\n\\n return model, inp_epoch, stats\",\n \"def load_checkpoint(self):\\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\\n try:\\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\\n ckpt = torch.load(self.params.resume_from)\\n self.epoch = ckpt['epoch']\\n try:\\n self.train_loss = ckpt['train_loss']\\n self.val_loss = ckpt['val_loss']\\n except:\\n self.train_loss = []\\n self.val_loss = []\\n self.network.load_state_dict(ckpt['state_dict'])\\n self.opt.load_state_dict(ckpt['optimizer'])\\n LOG('Checkpoint Loaded!')\\n LOG('Current Epoch: %d' % self.epoch)\\n self.ckpt_flag = True\\n except:\\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\\n else:\\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')\",\n \"def load_model_from_checkpoint(self, path: str):\\n ckpt = torch.load(path, map_location='cpu')\\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\\n self.net_q.head.load_state_dict(ckpt['head'])\\n self.net_ps.load_state_dict(ckpt['net_ps'])\\n self.net_k.load_state_dict(ckpt['net_k'])\\n self.queue.load_state_dict(ckpt['queue'])\\n self.optimizer.load_state_dict(ckpt['optimizer'])\\n if 'scheduler' in ckpt:\\n self.scheduler.load_stae_dict(ckpt['scheduler'])\\n self.move_optimizer_states(self.optimizer, self.local_rank)\",\n \"def load_checkpoint(self, label):\\n model_dir = os.path.join(\\n config.results_dir, config.experiment_name, 'checkpoints')\\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\\n\\n print(\\\"Loading model from {}\\\".format(model_file))\\n model_dict = torch.load(model_file)\\n\\n self.use_cuda = model_dict['use_cuda']\\n if self.use_cuda:\\n self.net.cuda()\\n\\n self.net.load_state_dict(model_dict['net_state_dict'])\",\n \"def load(cls, path):\\n print(f'load checkpoint from {path}')\\n if torch.cuda.is_available():\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\\n else:\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\\n \\n # model.flatten_parameters() # make RNN parameters contiguous\\n optimizer = resume_checkpoint['optimizer']\\n return Checkpoint(\\n model=model, \\n optimizer=optimizer,\\n epoch=resume_checkpoint['epoch'],\\n path=path\\n )\",\n \"def load_model(path):\\n if os.path.isfile(path):\\n print(\\\"=> loading checkpoint '{}'\\\".format(path))\\n checkpoint = torch.load(path)\\n\\n # # size of the top layer\\n # N = checkpoint['state_dict']['top_layer.bias'].size()\\n #\\n # # build skeleton of the model\\n # sob = 'sobel.0.weight' in checkpoint['state_dict'].keys()\\n # model = models.__dict__[checkpoint['arch']](sobel=sob, out=int(N[0]))\\n #\\n # # deal with a dataparallel table\\n # def rename_key(key):\\n # if not 'module' in key:\\n # return key\\n # return ''.join(key.split('.module'))\\n #\\n # checkpoint['state_dict'] = {rename_key(key): val\\n # for key, val\\n # in checkpoint['state_dict'].items()}\\n #\\n # # load weights\\n # model.load_state_dict(checkpoint['state_dict'])\\n # print(\\\"Loaded\\\")\\n # else:\\n # model = None\\n # print(\\\"=> no checkpoint found at '{}'\\\".format(path))\\n\\n # net = models.__dict__['ResNet18'](low_dim=128)\\n # net = models.__dict__['resnet18'](low_dim=128)\\n\\n net = models.__dict__['alexnet'](out=128)\\n # net = models.__dict__['Alexnet_C'](out=args.low_dim)\\n\\n net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))\\n net.load_state_dict(checkpoint['net'])\\n\\n return net\",\n \"def try_create_model_and_load_from_checkpoint(self) -> bool:\\n self.create_model()\\n if self.checkpoint_path:\\n # Load the stored model. If there is no checkpoint present, return immediately.\\n return self.try_load_checkpoint_for_model()\\n return True\",\n \"def load_model_trainer_states_from_checkpoint(self, checkpoint_path, model=None):\\n import os\\n\\n if model is None:\\n try:\\n import cloudpickle\\n except ImportError:\\n raise ImportError(\\\"cloudpickle is required to load model class\\\")\\n logger.info(\\\"Loading model class\\\")\\n model = cloudpickle.load(open(os.path.join(checkpoint_path, \\\"model_class.pkl\\\"), \\\"rb\\\"))\\n\\n self.model = HFWrapper(model)\\n logger.info(\\\"Loading weights of previously trained model\\\")\\n # Restoring model weights\\n self.model.load_state_dict(\\n # torch.load(os.path.join(training_args.output_dir, \\\"pytorch_model.bin\\\"))\\n torch.load(os.path.join(checkpoint_path, \\\"pytorch_model.bin\\\"))\\n )\\n # Restoring random state\\n rng_file = os.path.join(checkpoint_path, \\\"rng_state.pth\\\")\\n checkpoint_rng_state = torch.load(rng_file)\\n random.setstate(checkpoint_rng_state[\\\"python\\\"])\\n np.random.set_state(checkpoint_rng_state[\\\"numpy\\\"])\\n torch.random.set_rng_state(checkpoint_rng_state[\\\"cpu\\\"])\\n torch.cuda.random.set_rng_state_all(checkpoint_rng_state[\\\"cuda\\\"])\\n # Restoring AMP scaler\\n if self.use_amp:\\n self.scaler.load_state_dict(torch.load(os.path.join(checkpoint_path, \\\"scaler.pt\\\")))\",\n \"def load_model(path, model, optimizer):\\n print(\\\"LOADING MODEL...\\\")\\n ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)\\n status = ckpt.restore(tf.train.latest_checkpoint(path))\\n ckpt_manager = tf.train.CheckpointManager(\\n checkpoint=ckpt, \\n directory=FLAGS.model_dir, \\n max_to_keep=3 \\n )\\n return model, optimizer, ckpt, ckpt_manager\",\n \"def load_checkpoint(self, path: str = '', train: bool = True) -> int:\\n\\n if not path:\\n dir_ = os.path.dirname(os.path.realpath('__file__'))\\n path = os.path.join(dir_, 'model.pt')\\n\\n try:\\n ckpt = torch.load(path)\\n except FileNotFoundError:\\n return 0\\n else:\\n print('Loaded model at epoch: ', end='')\\n\\n self.load_state_dict(ckpt['model_state_dict'])\\n self.actor_optimizer.load_state_dict(ckpt['ac_optim_dict'])\\n self.critic_optimizer.load_state_dict(ckpt['critic_optim_dict'])\\n epoch = ckpt['epoch']\\n\\n print(epoch)\\n\\n if not train:\\n self.eval()\\n else:\\n self.train()\\n\\n return epoch\",\n \"def load_checkpoint(path: str, save_dir: str, cuda: bool = False, attention_viz: bool = False) -> nn.Module:\\r\\n # Load model and args\\r\\n state = torch.load(path, map_location=lambda storage, loc: storage)\\r\\n args, loaded_state_dict = state['args'], state['state_dict']\\r\\n\\r\\n # Update args with current args\\r\\n args.cuda = cuda\\r\\n args.attention_viz = attention_viz\\r\\n args.save_dir = save_dir\\r\\n\\r\\n model = build_model(args)\\r\\n model.load_state_dict(loaded_state_dict)\\r\\n\\r\\n if cuda:\\r\\n print('Moving model to cuda')\\r\\n model = model.cuda()\\r\\n\\r\\n return model\",\n \"def init_model(config: Union[str, Path, Config],\\n checkpoint: Optional[str] = None,\\n device: str = 'cuda:0',\\n cfg_options: Optional[dict] = None):\\n if isinstance(config, (str, Path)):\\n config = Config.fromfile(config)\\n elif not isinstance(config, Config):\\n raise TypeError('config must be a filename or Config object, '\\n 'but got {}'.format(type(config)))\\n if cfg_options is not None:\\n config.merge_from_dict(cfg_options)\\n elif 'init_cfg' in config.model.backbone:\\n config.model.backbone.init_cfg = None\\n config.model.pretrained = None\\n config.model.train_cfg = None\\n init_default_scope(config.get('default_scope', 'mmseg'))\\n\\n model = MODELS.build(config.model)\\n if checkpoint is not None:\\n checkpoint = load_checkpoint(model, checkpoint, map_location='cpu')\\n dataset_meta = checkpoint['meta'].get('dataset_meta', None)\\n # save the dataset_meta in the model for convenience\\n if 'dataset_meta' in checkpoint.get('meta', {}):\\n # mmseg 1.x\\n model.dataset_meta = dataset_meta\\n elif 'CLASSES' in checkpoint.get('meta', {}):\\n # < mmseg 1.x\\n classes = checkpoint['meta']['CLASSES']\\n palette = checkpoint['meta']['PALETTE']\\n model.dataset_meta = {'classes': classes, 'palette': palette}\\n else:\\n warnings.simplefilter('once')\\n warnings.warn(\\n 'dataset_meta or class names are not saved in the '\\n 'checkpoint\\\\'s meta data, classes and palette will be'\\n 'set according to num_classes ')\\n num_classes = model.decode_head.num_classes\\n dataset_name = None\\n for name in dataset_aliases.keys():\\n if len(get_classes(name)) == num_classes:\\n dataset_name = name\\n break\\n if dataset_name is None:\\n warnings.warn(\\n 'No suitable dataset found, use Cityscapes by default')\\n dataset_name = 'cityscapes'\\n model.dataset_meta = {\\n 'classes': get_classes(dataset_name),\\n 'palette': get_palette(dataset_name)\\n }\\n model.cfg = config # save the config in the model for convenience\\n model.to(device)\\n model.eval()\\n return model\",\n \"def create_model( session, batch_size ):\\n model = linear_model.LinearModel(\\n FLAGS.linear_size,\\n FLAGS.num_layers,\\n FLAGS.residual,\\n FLAGS.batch_norm,\\n FLAGS.max_norm,\\n batch_size,\\n FLAGS.learning_rate,\\n FLAGS.origin_bc,\\n summaries_dir,\\n dtype=tf.float16 if FLAGS.use_fp16 else tf.float32)\\n\\n if FLAGS.load <= 0:\\n # Create a new model from scratch\\n print(\\\"Creating model with fresh parameters.\\\")\\n session.run( tf.global_variables_initializer() )\\n return model\\n\\n # Load a previously saved model\\n ckpt = tf.train.get_checkpoint_state( train_dir, latest_filename=\\\"checkpoint\\\")\\n print( \\\"train_dir\\\", train_dir )\\n\\n if ckpt and ckpt.model_checkpoint_path:\\n # Check if the specific cpixels = pixels / pixels[2,:]heckpoint exists\\n if FLAGS.load > 0:\\n if os.path.isfile(os.path.join(train_dir,\\\"checkpoint-{0}.index\\\".format(FLAGS.load))):\\n ckpt_name = os.path.join( os.path.join(train_dir,\\\"checkpoint-{0}\\\".format(FLAGS.load)) )\\n else:\\n raise ValueError(\\\"Asked to load checkpoint {0}, but it does not seem to exist\\\".format(FLAGS.load))\\n else:\\n ckpt_name = os.path.basename( ckpt.model_checkpoint_path )\\n\\n print(\\\"Loading model {0}\\\".format( ckpt_name ))\\n model.saver.restore( session, ckpt.model_checkpoint_path )\\n return model\\n else:\\n print(\\\"Could not find checkpoint. Aborting.\\\")\\n raise( ValueError, \\\"Checkpoint {0} does not seem to exist\\\".format( ckpt.model_checkpoint_path ) )\\n\\n return model\",\n \"def load_from_checkpoint(results_dir, load_fn, args):\\n ckpt_dir = os.path.join(results_dir, \\\"tb\\\", \\\"version_0\\\", \\\"checkpoints\\\")\\n files = os.listdir(ckpt_dir)\\n assert len(files) > 0, \\\"Checkpoint directory is empty\\\"\\n ckpt_path = os.path.join(ckpt_dir, files[-1])\\n model = load_fn(checkpoint_path=ckpt_path, args=args)\\n return model\",\n \"def try_load_checkpoint_for_model(self) -> bool:\\n if self._model is None:\\n raise ValueError(\\\"Model must be created before it can be adjusted.\\\")\\n\\n if not self.checkpoint_path:\\n raise ValueError(\\\"No checkpoint provided\\\")\\n\\n if not self.checkpoint_path.is_file():\\n logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')\\n return False\\n\\n epoch = ModelAndInfo._load_checkpoint(model=self._model,\\n checkpoint_path=self.checkpoint_path,\\n key_in_state_dict=ModelAndInfo.MODEL_STATE_DICT_KEY,\\n use_gpu=self.config.use_gpu)\\n\\n logging.info(f\\\"Loaded model from checkpoint (epoch: {epoch})\\\")\\n self.checkpoint_epoch = epoch\\n return True\",\n \"def train_model(config: dict, load_weights=None, resume_epoch=None):\\n # Set GPU memory optimization\\n try:\\n physical_devices = tf.config.list_physical_devices(\\\"GPU\\\")\\n for index in range(len(physical_devices)):\\n try:\\n tf.config.experimental.set_memory_growth(physical_devices[index], True)\\n\\n except Exception as err:\\n print(\\\"[WARN]: Failed to set memory growth for {0}\\\".format(physical_devices[index]))\\n print(\\\"[WARN]: Error\\\", err, \\\" .Skipping memory optimization\\\")\\n\\n except Exception as err:\\n print(\\\"[WARN]: memory optimization failed. Error:\\\", err, \\\" . Skipping!\\\")\\n\\n # Set up random states\\n np.random.seed(100)\\n random.seed(100)\\n tf.random.set_seed(100)\\n\\n # Get the required configurations\\n no_of_epochs = config[\\\"no_of_epochs\\\"]\\n steps_per_epoch = config[\\\"steps_per_epoch\\\"] if config[\\\"steps_per_epoch\\\"] > 0 else None\\n\\n train_batch_size = config[\\\"train_batch_size\\\"]\\n val_batch_size = config[\\\"val_batch_size\\\"]\\n test_batch_size = config[\\\"test_batch_size\\\"]\\n\\n model_name = config[\\\"model_name\\\"]\\n\\n # Create the dataset\\n dataset_path = config[\\\"dataset_path\\\"]\\n dataset_family = config[\\\"dataset_family\\\"]\\n\\n # get width and height\\n image_width = config[\\\"image_width\\\"]\\n image_height = config[\\\"image_height\\\"]\\n initial_width = config[\\\"initial_width\\\"]\\n initial_height = config[\\\"initial_height\\\"]\\n\\n model_name = model_name + \\\"_\\\" + dataset_family\\n\\n print(\\\"[INFO]: Using Configuration: \\\\n\\\", config)\\n\\n # Set up environments\\n folders = [\\n \\\"./outputs/model_save/{0}/checkpoints/\\\".format(model_name),\\n \\\"./outputs/output_logs/{0}/csv_log/\\\".format(model_name),\\n \\\"./outputs/model_save/{0}/best_model/\\\".format(model_name),\\n \\\"./outputs/model_save/{0}/saved_model/\\\".format(model_name),\\n \\\"./outputs/output_logs/{0}/graphs/\\\".format(model_name)\\n ]\\n print(\\\"[INFO]: Setting up folders: \\\")\\n os_utilities.make_directories(paths=folders)\\n\\n # Load the dataset\\n print(\\\"[INFO]: Loading dataset\\\")\\n if dataset_family == \\\"CVC-ClinicDB\\\":\\n X, y = du.get_cvc_clinic_datapath(dataset_path)\\n elif dataset_family == \\\"Kvasir-Seg\\\":\\n X, y = du.get_kvasir_seg_datapath(dataset_path)\\n else:\\n print(\\\"[ERROR]: {0} dataset family is unrecognized or not supported!\\\".format(dataset_family))\\n raise NotImplementedError\\n\\n X_train, X_sided, y_train, y_sided = train_test_split(X, y, random_state=100, test_size=0.2)\\n X_val, X_test, y_val, y_test = train_test_split(X_sided, y_sided, random_state=100, test_size=0.5)\\n\\n print(\\\"[INFO]: Training set size: \\\", len(X_train))\\n print(\\\"[INFO]: Validation set size: \\\", len(X_val))\\n print(\\\"[INFO]: Testing set size: \\\", len(X_test))\\n\\n print(\\\"[INFO]: Loading Training set\\\")\\n train_datagen = du.DataGenerator(X_train,\\n y_train,\\n image_size=(image_width, image_height),\\n model_name=config[\\\"model_name\\\"],\\n batch_size=train_batch_size,\\n dataset_family=dataset_family,\\n initial_size=(initial_width, initial_height),\\n aug_config_path=\\\"./augmentation_config.yaml\\\",\\n shuffle=True)\\n\\n print(\\\"[INFO]: Loading Validation set\\\")\\n val_datagen = du.DataGenerator(X_val,\\n y_val,\\n image_size=(image_width, image_height),\\n model_name=config[\\\"model_name\\\"],\\n batch_size=val_batch_size,\\n dataset_family=dataset_family,\\n initial_size=None,\\n aug_config_path=None,\\n shuffle=False)\\n\\n print(\\\"[INFO]: Setting tf.data pipeline\\\")\\n train_steps = len(train_datagen) if steps_per_epoch is None else int(steps_per_epoch)\\n val_steps = len(val_datagen)\\n\\n train_dataset = train_datagen.get_tf_data()\\n val_dataset = val_datagen.get_tf_data()\\n\\n # Get the model, loss and metrics\\n print(\\\"[INFO]: Building the model - {0}\\\".format(model_name))\\n model = models.ModelSelector(config)\\n\\n # Load the weights if available\\n if load_weights is not None:\\n print(\\\"[INFO]: Load the weights from {0}\\\".format(load_weights))\\n model.load_weights(load_weights)\\n\\n # Setup Callbacks\\n print(\\\"[INFO]: Setting up training Callbacks and Optimizers. Its almost done\\\")\\n resume_epoch = 0 if resume_epoch is None else resume_epoch\\n overwrite = True if resume_epoch == 0 else False\\n\\n train_csv_logger = callbacks.CSVLogging(\\\"./outputs/output_logs/{0}/csv_log/train_log.csv\\\".format(model_name),\\n overwrite=overwrite)\\n valid_csv_logger = callbacks.CSVLogging(\\\"./outputs/output_logs/{0}/csv_log/valid_log.csv\\\".format(model_name),\\n overwrite=overwrite)\\n lr_reducer = callbacks.ReduceLROnPlateau(learning_rate=float(config[\\\"learning_rate\\\"]),\\n patience=4,\\n decay_rate=1E-1,\\n delta=0.0001,\\n min_lr=1E-7,\\n mode=\\\"min\\\")\\n\\n model_save_path = \\\"./outputs/model_save/{0}/\\\".format(model_name)\\n\\n # Setup Optimizer\\n optimizer = tf.keras.optimizers.Adam(learning_rate=float(config[\\\"learning_rate\\\"]))\\n\\n # Check for monitor\\n monitor_variable = 100.0 # Initialize a start max\\n\\n print(\\\"[INFO]: Setting up metrics\\\")\\n loss_avg = tf.keras.metrics.Mean(name=\\\"loss\\\")\\n f1_score_metric = tf.keras.metrics.Mean(name=\\\"f1_score\\\")\\n iou_coe_metric = tf.keras.metrics.Mean(name=\\\"iou_coe\\\")\\n dice_coe_metric = tf.keras.metrics.Mean(name=\\\"dice_coe\\\")\\n\\n # Set up a custom train loop\\n print(\\\"[INFO]: Beginning training loops\\\")\\n # Iterate epoch wise\\n for epoch in range(resume_epoch, no_of_epochs):\\n\\n print(\\\"Training {0}/{1}\\\".format(epoch + 1, no_of_epochs))\\n\\n try:\\n # Training-loop == using batches\\n train_loss, train_f1_score, train_iou, train_dice = train(config[\\\"model_name\\\"],\\n model,\\n train_dataset,\\n train_steps,\\n metrics_tracker=(loss_avg,\\n f1_score_metric,\\n iou_coe_metric,\\n dice_coe_metric),\\n optimizer=optimizer,\\n epoch=epoch + 1,\\n total_epochs=no_of_epochs)\\n\\n train_tracker = {\\n \\\"train_loss\\\": [train_loss],\\n \\\"train_f1_score\\\": [train_f1_score],\\n \\\"train_iou_coe\\\": [train_iou],\\n \\\"train_dice_coe\\\": [train_dice]\\n }\\n\\n # Validation loop == using batches\\n val_loss, val_f1_score, val_iou, val_dice = train(config[\\\"model_name\\\"],\\n model,\\n val_dataset,\\n val_steps,\\n metrics_tracker=(loss_avg,\\n f1_score_metric,\\n iou_coe_metric,\\n dice_coe_metric),\\n optimizer=None,\\n epoch=1,\\n total_epochs=1)\\n val_tracker = {\\n \\\"val_loss\\\": [val_loss],\\n \\\"val_f1_score\\\": [val_f1_score],\\n \\\"val_iou_coe\\\": [val_iou],\\n \\\"val_dice_coe\\\": [val_dice]\\n }\\n\\n model.save_weights(model_save_path + \\\"checkpoints/{0}_ckpt.h5\\\".format(model_name))\\n print(\\\"[INFO]: Epoch {0}/{1} - \\\\nTrain evaluation: {2}, \\\\nValidation evaluation: {3}\\\".\\n format(epoch + 1, no_of_epochs, train_tracker, val_tracker))\\n train_csv_logger.log(train_tracker)\\n valid_csv_logger.log(val_tracker)\\n\\n # Save the best model\\n if monitor_variable > val_loss:\\n monitor_variable = val_loss\\n model.save_weights(model_save_path + \\\"best_model/best_{0}.h5\\\".format(model_name))\\n\\n # LR Reduce\\n lr_reducer.check_lr(monitor_variable=val_loss, optimizer=optimizer)\\n\\n except KeyboardInterrupt:\\n print(\\\"[INFO]: Interrupted Training. Trying to save model\\\")\\n model.save_weights(model_save_path + \\\"{0}_{1}_interrupted.h5\\\".format(model_name, epoch + 1))\\n print(\\\"[INFO]: Attempting to run test on the best model so far!\\\")\\n break\\n\\n except Exception as err:\\n print(\\\"[ERROR]: Unexpected Critical Error: \\\", err)\\n print(\\\"[ERROR]: Trying to save the weights\\\")\\n model.save_weights(model_save_path + \\\"{0}_{1}_critical.h5\\\".format(model_name, epoch + 1))\\n traceback.print_exc()\\n sys.exit(2)\\n\\n print(\\\"[INFO]: Training completed. Saving model\\\")\\n model.save_weights(model_save_path + \\\"saved_model/{0}.h5\\\".format(model_name))\\n\\n print(\\\"[INFO]: Testing model\\\")\\n print(\\\"[INFO]: Loading Best saved model:\\\")\\n model.load_weights(model_save_path + \\\"best_model/best_{0}.h5\\\".format(model_name))\\n\\n print(\\\"[INFO]: Loading the test set\\\")\\n test_datagen = du.DataGenerator(X_test,\\n y_test,\\n image_size=(image_width, image_height),\\n model_name=config[\\\"model_name\\\"],\\n batch_size=test_batch_size,\\n dataset_family=dataset_family,\\n initial_size=None,\\n aug_config_path=None,\\n shuffle=False)\\n\\n print(\\\"[INFO]: Loading TF data\\\")\\n test_dataset = test_datagen.get_tf_data()\\n test_steps = len(test_datagen)\\n\\n print(\\\"[INFO]: Testing Initiated\\\")\\n test_loss, test_f1_score, test_iou, test_dice = train(config[\\\"model_name\\\"],\\n model,\\n test_dataset,\\n test_steps,\\n metrics_tracker=(loss_avg,\\n f1_score_metric,\\n iou_coe_metric,\\n dice_coe_metric),\\n optimizer=None,\\n epoch=1,\\n total_epochs=1)\\n test_tracker = {\\n \\\"test_loss\\\": [test_loss],\\n \\\"test_f1_score\\\": [test_f1_score],\\n \\\"test_iou_coe\\\": [test_iou],\\n \\\"test_dice_coe\\\": [test_dice]\\n }\\n print(\\\"[INFO]: Test Results: \\\\n\\\", test_tracker)\\n with open(\\\"./outputs/output_logs/{0}/test_results.txt\\\".format(model_name), mode=\\\"w\\\") as f:\\n f.write(\\\"Dumped Test Results for the model {0}\\\\n\\\".format(model_name))\\n for k, v in test_tracker.items():\\n f.write(\\\"{0} => {1}\\\\n\\\".format(k, v))\\n\\n print(\\\"[INFO]: Closing operations\\\")\",\n \"def create_reference_model(self, config, tmp_path_factory: pytest.TempPathFactory, *args):\\n config = copy.deepcopy(config) # ensure the reference model is not passed to tests\\n\\n save_folder = tmp_path_factory.mktemp('{device}-{precision}'.format(**config))\\n config.update({'save_interval': '1ep', 'save_folder': str(save_folder), 'save_filename': 'ep{epoch}.pt'})\\n\\n trainer = Trainer(**config)\\n trainer.fit()\\n\\n self.reference_model = trainer.state.model\\n self.reference_folder = save_folder\",\n \"def load_checkpoint(cfg, args):\\n checkpoint_iteration = args.checkpoint\\n bucket = connect_to_bucket(args.bucket)\\n # load actual checkpoint\\n if not os.path.isdir(cfg.OUTPUT_DIR):\\n os.mkdir(cfg.OUTPUT_DIR)\\n blob = bucket.blob(cfg.OUTPUT_DIR + \\\"/model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n blob.download_to_filename(cfg.OUTPUT_DIR + \\\"/model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n if args.resume:\\n # also write last checkpoint file for when --resume statement, model gets checkpoint name from this file\\n with open(cfg.OUTPUT_DIR + \\\"/last_checkpoint\\\", \\\"w\\\") as file:\\n file.write(\\\"model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n # return statement not clean, but useful for inference code\\n return checkpoint_iteration, bucket\",\n \"def load_checkpoint(self, session, model_dir):\\n assert self.params.cp_load == True, (\\\"cp_load must be set to true to load a checkpoint\\\")\\n self.loader.restore(session, model_dir)\",\n \"def init_model(session, model):\\n # If there is a checkpoint, load it\\n if not tf.gfile.Exists(FLAGS.train_dir):\\n tf.gfile.MkDir(FLAGS.train_dir)\\n ckpt = tf.train.get_checkpoint_state(FLAGS.train_dir)\\n if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path):\\n print(\\\"Reading model parameters from %s\\\" % ckpt.model_checkpoint_path)\\n model.saver.restore(session, ckpt.model_checkpoint_path)\\n\\n # Else initialize the variables\\n else:\\n if FLAGS.decode:\\n input(\\\"You sure you want to talk to an untrained chatbot? Press Ctrl-C to stop, Return to continue \\\")\\n print(\\\"Fine.\\\")\\n\\n print(\\\"Creating model with fresh parameters.\\\")\\n session.run(tf.global_variables_initializer())\",\n \"def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):\\n\\n config = kwargs.pop(\\\"config\\\", None)\\n state_dict = kwargs.pop(\\\"state_dict\\\", None)\\n cache_dir = kwargs.pop(\\\"cache_dir\\\", None)\\n from_tf = kwargs.pop(\\\"from_tf\\\", False)\\n from_hf = kwargs.pop(\\\"from_hf\\\", False)\\n output_loading_info = kwargs.pop(\\\"output_loading_info\\\", False)\\n default_gpu = kwargs.pop(\\\"default_gpu\\\", True)\\n\\n # Load config\\n assert config is not None\\n model_kwargs = kwargs\\n\\n # Load model\\n if pretrained_model_name_or_path in cls.pretrained_model_archive_map:\\n archive_file = cls.pretrained_model_archive_map[pretrained_model_name_or_path]\\n elif os.path.isdir(pretrained_model_name_or_path):\\n if from_tf:\\n # Directly load from a TensorFlow checkpoint\\n archive_file = os.path.join(pretrained_model_name_or_path, TF_WEIGHTS_NAME + \\\".index\\\")\\n else:\\n archive_file = os.path.join(pretrained_model_name_or_path, WEIGHTS_NAME)\\n else:\\n if from_tf:\\n # Directly load from a TensorFlow checkpoint\\n archive_file = pretrained_model_name_or_path + \\\".index\\\"\\n else:\\n archive_file = pretrained_model_name_or_path\\n # redirect to the cache, if necessary\\n try:\\n resolved_archive_file = cached_path(archive_file, cache_dir=cache_dir)\\n except EnvironmentError:\\n if pretrained_model_name_or_path in cls.pretrained_model_archive_map:\\n logger.error(\\\"Couldn't reach server at '{}' to download pretrained weights.\\\".format(archive_file))\\n else:\\n logger.error(\\n \\\"Model name '{}' was not found in model name list ({}). \\\"\\n \\\"We assumed '{}' was a path or url but couldn't find any file \\\"\\n \\\"associated to this path or url.\\\".format(\\n pretrained_model_name_or_path, \\\", \\\".join(cls.pretrained_model_archive_map.keys()), archive_file)\\n )\\n return None\\n if default_gpu:\\n if resolved_archive_file == archive_file:\\n logger.info(\\\"loading weights file {}\\\".format(archive_file))\\n else:\\n logger.info(\\\"loading weights file {} from cache at {}\\\".format(archive_file, resolved_archive_file))\\n\\n # Instantiate model.\\n model = cls(config, *model_args, **model_kwargs)\\n\\n if state_dict is None and not from_tf:\\n state_dict = torch.load(resolved_archive_file, map_location=\\\"cpu\\\")\\n if from_tf:\\n # Directly load from a TensorFlow checkpoint\\n return cls.load_tf_weights(model, config, resolved_archive_file[:-6]) # Remove the '.index'\\n\\n # Convert old format to new format if needed from a PyTorch state_dict\\n old_keys = []\\n new_keys = []\\n for key in state_dict.keys():\\n new_key = None\\n if \\\"gamma\\\" in key:\\n new_key = key.replace(\\\"gamma\\\", \\\"weight\\\")\\n if \\\"beta\\\" in key:\\n new_key = key.replace(\\\"beta\\\", \\\"bias\\\")\\n if new_key:\\n old_keys.append(key)\\n new_keys.append(new_key)\\n for old_key, new_key in zip(old_keys, new_keys):\\n state_dict[new_key] = state_dict.pop(old_key)\\n\\n # Rename Bert parameters for our framework\\n # NB: Assume 1 Bert layer is mapped to 1 layer only (cannot be used to init multiple layers)\\n old_keys = []\\n new_keys = []\\n nums = []\\n for key in state_dict.keys():\\n new_key = None\\n if \\\".layer.\\\" in key and from_hf:\\n num = int(key.split(\\\".layer.\\\")[-1].split(\\\".\\\")[0])\\n if \\\".attention.\\\" in key:\\n new_key = key.replace(\\\".layer.%d.attention.\\\" % num,\\n \\\".layer.%d.attention_\\\" % config.bert_layer2attn_sublayer.get(str(num), num))\\n elif \\\".intermediate.\\\" in key:\\n new_key = key.replace(\\\".layer.%d.intermediate.\\\" % num,\\n \\\".layer.%d.intermediate.\\\" % config.bert_layer2ff_sublayer.get(str(num), num))\\n elif \\\".output.\\\" in key:\\n new_key = key.replace(\\\".layer.%d.output.\\\" % num,\\n \\\".layer.%d.output.\\\" % config.bert_layer2ff_sublayer.get(str(num), num))\\n if new_key:\\n old_keys.append(key)\\n new_keys.append(new_key)\\n nums.append(num)\\n for old_key, new_key, _ in sorted(zip(old_keys, new_keys, nums), key=lambda x: x[2], reverse=True):\\n state_dict[new_key] = state_dict.pop(old_key)\\n\\n # Load from a PyTorch state_dict\\n missing_keys = []\\n unexpected_keys = []\\n error_msgs = []\\n # copy state_dict so _load_from_state_dict can modify it\\n metadata = getattr(state_dict, \\\"_metadata\\\", None)\\n state_dict = state_dict.copy()\\n if metadata is not None:\\n state_dict._metadata = metadata\\n\\n def load(module, prefix=\\\"\\\"):\\n local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {})\\n module._load_from_state_dict(\\n state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs,\\n )\\n for name, child in module._modules.items():\\n if child is not None:\\n load(child, prefix + name + \\\".\\\")\\n\\n # Make sure we are able to load base models as well as derived models (with heads)\\n start_prefix = \\\"\\\"\\n model_to_load = model\\n if not hasattr(model, cls.base_model_prefix) and any(\\n s.startswith(cls.base_model_prefix) for s in state_dict.keys()\\n ):\\n start_prefix = cls.base_model_prefix + \\\".\\\"\\n if hasattr(model, cls.base_model_prefix) and not any(\\n s.startswith(cls.base_model_prefix) for s in state_dict.keys()\\n ):\\n model_to_load = getattr(model, cls.base_model_prefix)\\n\\n logger.info(start_prefix)\\n load(model_to_load, prefix=start_prefix)\\n if len(missing_keys) > 0 and default_gpu:\\n logger.info(\\n \\\"Weights of {} not initialized from pretrained model: {}\\\".format(model.__class__.__name__, missing_keys)\\n )\\n if len(unexpected_keys) > 0 and default_gpu:\\n logger.info(\\n \\\"Weights from pretrained model not used in {}: {}\\\".format(model.__class__.__name__, unexpected_keys)\\n )\\n if len(error_msgs) > 0 and default_gpu:\\n raise RuntimeError(\\n \\\"Error(s) in loading state_dict for {}:\\\\n\\\\t{}\\\".format(model.__class__.__name__, \\\"\\\\n\\\\t\\\".join(error_msgs))\\n )\\n\\n if hasattr(model, \\\"tie_weights\\\"):\\n model.tie_weights() # make sure word embedding weights are still tied\\n\\n # Set model in evaluation mode to desactivate DropOut modules by default\\n model.eval()\\n\\n if output_loading_info:\\n loading_info = {\\n \\\"missing_keys\\\": missing_keys,\\n \\\"unexpected_keys\\\": unexpected_keys,\\n \\\"error_msgs\\\": error_msgs,\\n }\\n return model, loading_info\\n\\n return model\",\n \"def load_ckpt(self, name=None):\\r\\n name = name if name == 'latest' else \\\"ckpt_epoch{}\\\".format(name)\\r\\n load_path = os.path.join(self.model_dir, \\\"{}.pth\\\".format(name))\\r\\n if not os.path.exists(load_path):\\r\\n raise ValueError(\\\"Checkpoint {} not exists.\\\".format(load_path))\\r\\n\\r\\n checkpoint = torch.load(load_path)\\r\\n print(\\\"Checkpoint loaded from {}\\\".format(load_path))\\r\\n if isinstance(self.net, nn.DataParallel):\\r\\n self.net.module.load_state_dict(checkpoint['model_state_dict'])\\r\\n else:\\r\\n self.net.load_state_dict(checkpoint['model_state_dict'])\\r\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\r\\n self.scheduler.load_state_dict(checkpoint['scheduler_state_dict'])\\r\\n self.clock.restore_checkpoint(checkpoint['clock'])\",\n \"def load_checkpoint(ckpt_path):\\n checkpoint = None\\n if ckpt_path:\\n logger.info(\\\"Loading checkpoint from %s\\\" % ckpt_path)\\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\\\"cpu\\\"))\\n\\n if \\\"model\\\" in checkpoint.keys():\\n # This preserves backward-compat for models using customed layernorm\\n def fix_key(s):\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.b_2\\\", r\\\"\\\\1.layer_norm\\\\2.bias\\\", s\\n )\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.a_2\\\", r\\\"\\\\1.layer_norm\\\\2.weight\\\", s\\n )\\n return s\\n\\n checkpoint[\\\"model\\\"] = {\\n fix_key(k): v for k, v in checkpoint[\\\"model\\\"].items()\\n }\\n # Force add_ffnbias to True if bias found in model w_1 keys\\n for key in checkpoint[\\\"model\\\"].keys():\\n if \\\"w_1.bias\\\" in key:\\n checkpoint[\\\"opt\\\"].add_ffnbias = True\\n\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"num_kv\\\"):\\n checkpoint[\\\"opt\\\"].num_kv = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"add_ffnbias\\\"):\\n checkpoint[\\\"opt\\\"].add_ffnbias = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_residual\\\"):\\n checkpoint[\\\"opt\\\"].parallel_residual = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"shared_layer_norm\\\"):\\n checkpoint[\\\"opt\\\"].shared_layer_norm = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"use_ckpting\\\"):\\n checkpoint[\\\"opt\\\"].use_ckpting = []\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"relative_positions_buckets\\\"):\\n checkpoint[\\\"opt\\\"].relative_positions_buckets = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_mode\\\"):\\n checkpoint[\\\"opt\\\"].parallel_mode = \\\"data_parallel\\\"\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"norm_eps\\\"):\\n checkpoint[\\\"opt\\\"].norm_eps = 1e-6\\n\\n # fix v2 compatibility\\n if \\\"generator\\\" in checkpoint.keys() and checkpoint[\\\"generator\\\"]:\\n if \\\"0.weight\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"weight\\\"] = checkpoint[\\\"generator\\\"].pop(\\n \\\"0.weight\\\"\\n )\\n if \\\"0.bias\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"bias\\\"] = checkpoint[\\\"generator\\\"].pop(\\\"0.bias\\\")\\n # end of patch for backward compatibility\\n\\n return checkpoint\",\n \"def load_checkpoint(self, model):\\n print(f\\\"load model {self.save_model_path}\\\")\\n model.load_state_dict(torch.load(self.save_model_path))\",\n \"def load(loadname, checkpoint=None):\\n ckpt_dir = \\\"./models/tf_ckpt_\\\" + loadname + \\\"/\\\"\\n if checkpoint is not None:\\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\\n status.assert_consumed()\\n print(\\\"Loaded checkpoint\\\")\\n else:\\n print(\\\"Not Loading any checkpoint\\\")\\n print(\\\"Starting training from initial configuration\\\")\",\n \"def _init_model(self, checkpoint_path: str) -> None:\\n # load weights\\n logger.info(f\\\"Load weights from the checkpoint {checkpoint_path}\\\")\\n checkpoint = torch.load(checkpoint_path, map_location=torch.device(\\\"cpu\\\"))\\n\\n state_dict = checkpoint[\\\"state_dict\\\"]\\n self.orig_acc = checkpoint[\\\"test_acc\\\"]\\n\\n is_pruned = (\\n next((name for name in state_dict if \\\"mask\\\" in name), None) is not None\\n )\\n\\n if is_pruned:\\n logger.info(\\\"Dummy prunning to load pruned weights\\\")\\n model_utils.dummy_pruning(self.params_all)\\n\\n model_utils.initialize_params(self.model, state_dict)\\n logger.info(\\\"Initialized weights\\\")\\n\\n # check the trained model is pruned\\n\\n if is_pruned:\\n logger.info(\\n \\\"Get masks and remove prunning reparameterization for prepare_qat\\\"\\n )\\n self.mask = model_utils.get_masks(self.model)\\n model_utils.remove_pruning_reparameterization(self.params_all)\",\n \"def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\\n print(\\\"Loading checkpoint: {}\\\".format(checkpoint_path))\\n state = torch.load(checkpoint_path)\\n self.model.load_state_dict(state['state_dict'])\\n self.optimizer.load_state_dict(state['optim_dict'])\\n\\n if continue_from_epoch:\\n self.epoch = state['epoch']\",\n \"def load_model(self, ckpt_name=\\\"best_model.pth\\\"):\\n path = \\\"/\\\".join(ckpt_name.split(\\\"/\\\")[:-1])\\n chkpt = torch.load(ckpt_name)\\n self.start_epoch = chkpt['epoch']\\n self.best_metric = chkpt['best_metric']\\n\\n # fix the DataParallel caused problem with keys names\\n if self.multi_gpu_flag:\\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=False)\\n self.net.load_state_dict(new_state_dict)\\n else:\\n try:\\n self.net.load_state_dict(chkpt['state_dict'])\\n except:\\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=True)\\n self.net.load_state_dict(new_state_dict)\\n\\n if self.load_optimizer_state:\\n self.optimizer.load_state_dict(chkpt['optimizer'])\\n logging.info(\\\"******** State loaded ********\\\")\\n\\n training_meta = pickle.load(open(f\\\"{path}/training_meta.pickle.dat\\\", \\\"rb\\\"))\\n for k, v in training_meta.items():\\n if k in self.__class__.__params:\\n setattr(self, k, v)\\n logging.info(\\\"******** Training params loaded ********\\\")\",\n \"def create_model(model_name, random_state, epoch, device, log_path, **hparams):\\n model = eval(f'{model_name}')(\\n **hparams, epoch=int(epoch), random_state=random_state, device=device,\\n log_path=log_path\\n )\\n\\n return model\",\n \"def create_checkpoint(model, save_dir, train_data):\\n model.class_to_idx = train_data.class_to_idx\\n\\n checkpoint = {\\n 'model': model.name,\\n 'classifier': model.classifier,\\n 'class_to_idx': model.class_to_idx,\\n 'state_dict': model.state_dict()\\n }\\n\\n if save_dir and isdir(save_dir):\\n torch.save(checkpoint, save_dir + 'checkpoint.pth')\\n print('checkpoint created')\\n else: \\n print(\\\"Directory not found. Saving at current directory in checkpoint.pth\\\")\\n torch.save(checkpoint, 'checkpoint.pth')\",\n \"def __init__(self, model: str, **kwargs):\\n super().__init__(model=model, **kwargs)\\n self.path = model\\n self.model = get_zennet()\\n\\n model_pth_path = osp.join(self.path, ModelFile.TORCH_MODEL_FILE)\\n\\n checkpoint = torch.load(model_pth_path, map_location='cpu')\\n if 'state_dict' in checkpoint:\\n state_dict = checkpoint['state_dict']\\n else:\\n state_dict = checkpoint\\n\\n self.model.load_state_dict(state_dict, strict=True)\\n logger.info('load model done')\",\n \"def load_checkpoint(self, checkpoint_dir):\\r\\n\\r\\n if not os.path.exists(checkpoint_dir):\\r\\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\\r\\n\\r\\n path = os.path.join(checkpoint_dir, 'model.pt')\\r\\n self.model.load_state_dict(torch.load(path, self.device))\\r\\n self.update()\",\n \"def get_checkpoint(model, checkpoint='-1'):\\n if not os.path.isfile(os.path.join(model, \\\"checkpoint\\\")):\\n sys.exit(\\\"[ERROR] Cannot find checkpoint in %s.\\\" % model)\\n ckpt = tf.train.get_checkpoint_state(model)\\n\\n model_checkpoint_path = ckpt.model_checkpoint_path\\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\\n\\n if not ckpt or not model_checkpoint_path:\\n sys.exit(\\\"[ERROR] Cannot read checkpoint %s.\\\" % os.path.join(model, \\\"checkpoint\\\"))\\n\\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\\n steps = sorted(steps)\\n if checkpoint == \\\"last\\\":\\n tf.logging.info(\\\"Load the last saved model.\\\")\\n checkpoint = steps[-1]\\n else:\\n checkpoint = int(checkpoint)\\n if checkpoint == -1:\\n tf.logging.info(\\\"Load the best model according to valid_loss\\\")\\n min_epoch = -1\\n min_loss = 1e10\\n with open(os.path.join(model, \\\"valid_loss\\\")) as f:\\n for line in f.readlines():\\n epoch, loss, eer = line.split(\\\" \\\")\\n epoch = int(epoch)\\n loss = float(loss)\\n if loss < min_loss:\\n min_loss = loss\\n min_epoch = epoch\\n # Add 1 to min_epoch since epoch is 0-based\\n config_json = os.path.join(model, \\\"config.json\\\")\\n params = Params(config_json)\\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\\n tf.logging.info(\\\"The checkpoint is %d\\\" % checkpoint)\\n assert checkpoint in steps, \\\"The checkpoint %d not in the model directory\\\" % checkpoint\\n\\n model_checkpoint_path = model_checkpoint_path.rsplit(\\\"-\\\", 1)[0] + \\\"-\\\" + str(checkpoint)\\n model_checkpoint_path = os.path.join(model, os.path.basename(model_checkpoint_path))\\n\\n with open(os.path.join(model, \\\"checkpoint\\\"), \\\"w\\\") as f:\\n f.write(\\\"model_checkpoint_path: \\\\\\\"%s\\\\\\\"\\\\n\\\" % model_checkpoint_path)\\n for checkpoint in all_model_checkpoint_paths:\\n checkpoint_new = os.path.join(model, os.path.basename(checkpoint))\\n f.write(\\\"all_model_checkpoint_paths: \\\\\\\"%s\\\\\\\"\\\\n\\\" % checkpoint_new)\\n return model_checkpoint_path\",\n \"def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\\n print(\\\"Load checkpoint from: {}\\\".format(path))\\n state_dict, optimizer_state = _load(path)\\n\\n model.load_dict(state_dict)\\n if not reset_optimizer and optimizer is not None:\\n if optimizer_state is not None:\\n print(\\\"[loading] Load optimizer state from {}\\\".format(path))\\n optimizer.load(optimizer_state)\\n\\n return model\",\n \"def initialize_model_from_cfg(args, gpu_id=0):\\n model = eval(args.model).loot_model(args)\\n model.eval()\\n\\n if args.cuda:\\n model.cuda()\\n\\n if args.load_ckpt:\\n load_name = args.load_ckpt\\n logger.info(\\\"loading checkpoint %s\\\", load_name)\\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\\n net_utils.load_ckpt(model, checkpoint['model'])\\n\\n if args.load_detectron:\\n logger.info(\\\"loading detectron weights %s\\\", args.load_detectron)\\n load_detectron_weight(model, args.load_detectron)\\n\\n\\n return model\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint)\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\\n self.model.load_state_dict(checkpoint[\\\"model_state_dict\\\"])\\n self.optimizer.load_state_dict(checkpoint[\\\"optimizer_state_dict\\\"])\\n return self\",\n \"def _load_weights_to_model(self, model: nn.Module,\\n checkpoint: Optional[dict],\\n cfg: Optional[ConfigType]) -> None:\\n if checkpoint is not None:\\n _load_checkpoint_to_model(model, checkpoint)\\n else:\\n warnings.warn('Checkpoint is not loaded, and the inference '\\n 'result is calculated by the randomly initialized '\\n 'model!')\",\n \"def load_checkpoint(model, save_path):\\n model.load_state_dict(torch.load(save_path))\",\n \"def load_checkpoint(model, model_name='model', validation_id=None):\\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\\n _load_model(model.module if type(model) is torch.nn.DataParallel else model, model_name, path=path, reload=True)\",\n \"def load_model(self, fname: str) -> None:\\n checkpoint_data = torch.load(fname)\\n\\n # Load the models\\n # P-Net\\n model_import_path = checkpoint_data['p_net']['model_import_path']\\n imp = importlib.import_module(model_import_path)\\n mod = getattr(imp, checkpoint_data['p_net']['model_name'])\\n self.p_net = mod()\\n self.p_net.set_params(checkpoint_data['p_net'])\\n # Q-Net\\n model_import_path = checkpoint_data['q_net']['model_import_path']\\n imp = importlib.import_module(model_import_path)\\n mod = getattr(imp, checkpoint_data['q_net']['model_name'])\\n self.q_net = mod()\\n self.q_net.set_params(checkpoint_data['q_net'])\",\n \"def load_model (checkpoint_path, model, opt_fn=None, loss_fn=None, epoch=None):\\n\\n if not os.path.exists(checkpoint_path):\\n raise Exception (\\\"The {} does not exist!\\\".format(checkpoint_path))\\n\\n ckpt = torch.load(checkpoint_path)\\n model.load_state_dict(ckpt['model_state_dict'])\\n\\n if opt_fn is not None and loss_fn is not None:\\n opt_fn.load_state_dict(ckpt['optimizer_state_dict'])\\n epoch = ckpt['epoch']\\n loss_fn = ckpt['loss']\\n return model, opt_fn, loss_fn, epoch\\n else:\\n return model\",\n \"def checkpoint_load(checkpoint_path, gpu):\\n model_info = torch.load(checkpoint_path)\\n model = models.vgg19(pretrained=True)\\n for param in model.parameters():\\n param.requires_grad = False\\n \\n model.class_to_idx = model_info['class_to_idx']\\n\\n model = classifier(model)\\n model.load_state_dict(model_info[\\\"model_state_dict\\\"])\\n return model, model.class_to_idx\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load(self, checkpoint_dir=None):\\n\\n if checkpoint_dir is None:\\n checkpoint_dir = FLAGS.checkpoint_dir\\n\\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\\n\\n return self.load_from_path(checkpoint_dir)\",\n \"def get_pretrain_model(pretrain_model, target_model, checkpoint='-1'):\\n if not os.path.isfile(os.path.join(pretrain_model, \\\"checkpoint\\\")):\\n sys.exit(\\\"[ERROR] Cannot find checkpoint in %s.\\\" % pretrain_model)\\n ckpt = tf.train.get_checkpoint_state(pretrain_model)\\n\\n model_checkpoint_path = ckpt.model_checkpoint_path\\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\\n\\n if not ckpt or not model_checkpoint_path:\\n sys.exit(\\\"[ERROR] Cannot read checkpoint %s.\\\" % os.path.join(pretrain_model, \\\"checkpoint\\\"))\\n\\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\\n steps = sorted(steps)\\n\\n if checkpoint == \\\"last\\\":\\n tf.logging.info(\\\"Load the last saved model.\\\")\\n checkpoint = steps[-1]\\n else:\\n checkpoint = int(checkpoint)\\n if checkpoint == -1:\\n tf.logging.info(\\\"Load the best model according to valid_loss\\\")\\n min_epoch = -1\\n min_loss = 1e10\\n with open(os.path.join(pretrain_model, \\\"valid_loss\\\")) as f:\\n for line in f.readlines():\\n epoch, loss, eer = line.split(\\\" \\\")\\n epoch = int(epoch)\\n loss = float(loss)\\n if loss < min_loss:\\n min_loss = loss\\n min_epoch = epoch\\n # Add 1 to min_epoch since epoch is 0-based\\n config_json = os.path.join(pretrain_model, \\\"config.json\\\")\\n params = Params(config_json)\\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\\n assert checkpoint in steps, \\\"The checkpoint %d not in the model directory\\\" % checkpoint\\n\\n pretrain_model_checkpoint_path = model_checkpoint_path.rsplit(\\\"-\\\", 1)[0] + \\\"-\\\" + str(checkpoint)\\n tf.logging.info(\\\"Copy the pre-trained model %s as the fine-tuned initialization\\\" % pretrain_model_checkpoint_path)\\n\\n import glob\\n for filename in glob.glob(pretrain_model_checkpoint_path + \\\"*\\\"):\\n bas = os.path.basename(filename).split(\\\"-\\\", 1)[0]\\n ext = os.path.basename(filename).rsplit(\\\".\\\", 1)[1]\\n shutil.copyfile(filename, os.path.join(target_model, bas + \\\"-0.\\\" + ext))\\n\\n with open(os.path.join(target_model, \\\"checkpoint\\\"), \\\"w\\\") as f:\\n f.write(\\\"model_checkpoint_path: \\\\\\\"%s\\\\\\\"\\\\n\\\" % os.path.join(target_model, os.path.basename(model_checkpoint_path).rsplit(\\\"-\\\", 1)[0] + \\\"-0\\\"))\\n f.write(\\\"all_model_checkpoint_paths: \\\\\\\"%s\\\\\\\"\\\\n\\\" % os.path.join(target_model, os.path.basename(model_checkpoint_path).rsplit(\\\"-\\\", 1)[0] + \\\"-0\\\"))\\n return\",\n \"def train(self, config: ConfigurationNode = None):\\n if config is None:\\n config = self.config\\n # Create writable timestamp for easier record keeping\\n timestamp = datetime.now().isoformat(sep=\\\"T\\\", timespec=\\\"auto\\\")\\n name_timestamp = timestamp.replace(\\\":\\\", \\\"_\\\")\\n\\n # Start the mlflow run:\\n mlflow.start_run(run_name=name_timestamp)\\n\\n # Check valid output path, set path from the path_cfg_override modules respectively\\n assert config.OUTPUT_PATH != ''\\n path_output = config.OUTPUT_PATH # output folder\\n path_train = config.DATASET.TRAIN_DATA_PATH # training data folder\\n path_val = config.DATASET.VAL_DATA_PATH # validation data folder\\n\\n # Make output dir and its parents if not exist.\\n if not os.path.exists(path_output):\\n os.makedirs(path_output)\\n\\n # Make result folders if they do not exist.\\n self.results_dir = (Path(path_output) / name_timestamp)\\n if not os.path.exists(self.results_dir):\\n os.makedirs(self.results_dir)\\n\\n # Make backup folders if they do not exist.\\n self.backup_dir = os.path.join(self.results_dir, 'model_backups')\\n if not os.path.exists(self.backup_dir):\\n os.makedirs(self.backup_dir)\\n\\n writer_tensorboard = SummaryWriter(log_dir=Path(self.results_dir / \\\"logs_tensorflow\\\"))\\n\\n # Now that CFG has been properly merged with new data along the way, time to dump a version of it into a string for trackability purposes.\\n config.dump(stream=open(os.path.join(self.results_dir, f'config{name_timestamp}.yaml'), 'w'))\\n\\n # file path to store the state of the model.\\n state_fpath = os.path.join(self.results_dir, f'model{name_timestamp}.pt')\\n\\n # ????\\n perf_path = os.path.join(self.results_dir, f'trace{name_timestamp}.p')\\n perf_trace = []\\n\\n # Load data, create the data loader objects from them.\\n data_train = pickle.load(open(path_train, 'rb'))\\n data_val = pickle.load(open(path_val, 'rb'))\\n self.loader_train = build_data_loader(data_train, config.DATASET, True)\\n self.loader_val = build_data_loader(data_val, config.DATASET, False)\\n\\n # Build the model using configue dict node\\n self.model = build_model(config.MODEL)\\n\\n # Enable parallel multi GPU mode if the config specify it.\\n if config.MODEL.PARALLEL:\\n print(\\\"Utilized parallel processing\\\")\\n self.model = torch.nn.DataParallel(self.model)\\n\\n current_epoch = 0\\n\\n # For resuming training (i.e. load checkpoint)\\n if config.RESUME_PATH != \\\"\\\":\\n checkpoint = torch.load(config.RESUME_PATH, map_location='cpu')\\n current_epoch = checkpoint['epoch']\\n self.model.load_state_dict(checkpoint[\\\"model_state\\\"])\\n _ = self.model.cuda()\\n\\n # SOLVER EVALUATOR\\n cfg_solver = config.MODEL.SOLVER\\n\\n # Build optimizer (between train/validation, using the solver portion of the configuration.\\n optimizer = build_optimizer(self.model, cfg_solver)\\n\\n # Build evaluator (between train/validation, using the solver portion of the configuration.\\n evaluator = build_evaluator(cfg_solver)\\n\\n evaluator.float().cuda()\\n total_epochs = cfg_solver.TOTAL_EPOCHS\\n\\n\\n # Main training epoch loop starts here.\\n for epoch in range(current_epoch, total_epochs):\\n\\n # Train a single epoch\\n self.train_epoch(epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard)\\n\\n mlflow.end_run()\",\n \"def eval_model(config):\\n print 'Model directory: %s' % config.model_output\\n print 'Running model: %s' % config.model_type\\n if config.model_type == 'fully_connected_mlp':\\n from models.fully_connected_mlp import model_struct\\n elif config.model_type == 'fully_connected_mlp_2l':\\n from models.fully_connected_mlp_2l import model_struct\\n elif config.model_type == 'fully_connected_conv':\\n from models.fully_connected_conv import model_struct\\n elif config.model_type == 'vgg_feature_model':\\n from models.vgg_feature_model import model_struct\\n else:\\n raise Exception\\n\\n # Prepare model training\\n dt_stamp = re.split(\\n '\\\\.', str(datetime.now()))[0].\\\\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\\n dt_dataset = config.model_type + '_' + dt_stamp + '/'\\n config.train_checkpoint = os.path.join(\\n config.model_output, dt_dataset) # timestamp this run\\n config.summary_dir = os.path.join(\\n config.train_summaries, config.model_output, dt_dataset)\\n dir_list = [config.train_checkpoint, config.summary_dir]\\n [make_dir(d) for d in dir_list]\\n\\n # Prepare model inputs\\n train_data = os.path.join(config.tfrecord_dir, 'train.tfrecords')\\n validation_data = os.path.join(config.tfrecord_dir, 'val.tfrecords')\\n feat_mean = 0 # np.mean(np.load(config.mean_file)['feat_list'])\\n\\n # Prepare data on CPU\\n with tf.device('/cpu:0'):\\n train_images, train_labels = inputs(\\n tfrecord_file=train_data,\\n batch_size=config.train_batch,\\n num_feats=config.n_features,\\n sample=config.sample['train'],\\n max_pixels_per_image=config.max_pixels_per_image,\\n im_size=config.resize,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n num_epochs=config.epochs,\\n feat_mean_value=feat_mean)\\n val_images, val_labels = inputs(\\n tfrecord_file=validation_data,\\n batch_size=1,\\n num_feats=config.n_features,\\n sample=config.sample['val'],\\n max_pixels_per_image=config.max_pixels_per_image,\\n im_size=config.resize,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n num_epochs=config.epochs,\\n feat_mean_value=feat_mean)\\n tf.summary.image('validation images', tf.cast(val_labels, tf.float32))\\n\\n # Prepare model on GPU\\n with tf.device('/gpu:0'):\\n with tf.variable_scope('cnn') as scope:\\n\\n model = model_struct()\\n train_mode = tf.get_variable(name='training', initializer=True)\\n model.build(\\n features=train_images,\\n output_categories=len(config.labels.keys()),\\n train_mode=train_mode, batchnorm=config.batch_norm)\\n\\n # Prepare the cost function\\n cost = softmax_cost(\\n model.res_logits, train_labels, ratio=config.ratio,\\n label_reshape=[\\n config.batch_size * config.max_pixels_per_image])\\n train_op = tf.train.AdamOptimizer(config.lr).minimize(cost)\\n\\n tf.summary.scalar(\\\"cost\\\", cost)\\n\\n train_score = correlation(\\n model.prob, train_labels) # training accuracy\\n tf.summary.scalar(\\\"training correlation\\\", train_score)\\n\\n # Setup validation op\\n if validation_data is not False:\\n scope.reuse_variables()\\n # Validation graph is the same as training except no batchnorm\\n val_model = model_struct()\\n val_model.build(\\n features=val_images,\\n output_categories=len(config.labels.keys()))\\n\\n # Calculate validation accuracy\\n val_pred = tf.cast(\\n tf.reshape(\\n tf.argmax(\\n val_model.prob, axis=1),\\n [1, config.resize[0], config.resize[1], 1]),\\n tf.float32)\\n tf.summary.image('validation prediction', val_pred)\\n val_score = correlation(\\n val_model.prob, tf.reshape(\\n val_labels, [np.prod(config.resize), 1]))\\n tf.summary.scalar(\\\"validation correlation\\\", val_score)\\n\\n # Set up summaries and saver\\n saver = tf.train.Saver(\\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\\n summary_op = tf.summary.merge_all()\\n\\n # Initialize the graph\\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\\n\\n # Need to initialize both of these if supplying num_epochs to inputs\\n sess.run(tf.group(tf.global_variables_initializer(),\\n tf.local_variables_initializer()))\\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\\n\\n # Set up exemplar threading\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\\n\\n # Start training loop\\n np.save(config.train_checkpoint, config)\\n step, val_max, losses = 0, 0, []\\n train_acc = 0\\n try:\\n while not coord.should_stop():\\n start_time = time.time()\\n _, loss_value, train_acc = sess.run([train_op, cost, train_score])\\n losses.append(loss_value)\\n duration = time.time() - start_time\\n assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\\n\\n if step % 100 == 0 and step % 10 == 0:\\n if validation_data is not False:\\n _, val_acc, val_frame = sess.run(\\n [train_op, val_score, val_pred])\\n\\n np.save(\\n os.path.join(\\n config.model_output, '%s_val_image' % step),\\n val_frame)\\n else:\\n val_acc = -1 # Store every checkpoint\\n\\n # Summaries\\n summary_str = sess.run(summary_op)\\n summary_writer.add_summary(summary_str, step)\\n\\n # Training status and validation accuracy\\n format_str = (\\n '%s: step %d, loss = %.2f (%.1f examples/sec; '\\n '%.3f sec/batch) | Training r = %s | '\\n 'Validation r = %s | logdir = %s')\\n print (format_str % (\\n datetime.now(), step, loss_value,\\n config.train_batch / duration, float(duration),\\n train_acc, val_acc, config.summary_dir))\\n\\n # Save the model checkpoint if it's the best yet\\n if val_acc > val_max:\\n saver.save(\\n sess, os.path.join(\\n config.train_checkpoint,\\n 'model_' + str(step) + '.ckpt'), global_step=step)\\n\\n # Store the new max validation accuracy\\n val_max = val_acc\\n\\n else:\\n # Training status\\n format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; '\\n '%.3f sec/batch) | Training F = %s')\\n print (format_str % (datetime.now(), step, loss_value,\\n config.train_batch / duration,\\n float(duration), train_acc))\\n # End iteration\\n step += 1\\n\\n except tf.errors.OutOfRangeError:\\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\\n finally:\\n coord.request_stop()\\n\\n dt_stamp = get_dt() # date-time stamp\\n np.save(\\n os.path.join(\\n config.tfrecord_dir, '%straining_loss' % dt_stamp), losses)\\n coord.join(threads)\\n sess.close()\",\n \"def load_pretrained_model(self,model_dir):\\n rnn_params = json.load(open(os.path.join(model_dir,\\n \\\"./model.json\\\")))[\\\"rnn\\\"]\\n\\n logging.info(\\\"Loading model from: {}\\\".format(model_dir))\\n self.create_training_model(model_dir = model_dir,\\n **rnn_params)\\n #从目录中读取神经网络参数\\n self.set_model_from_file()\",\n \"def checkpoint_model(PATH, ckpt_id, model, epoch, last_global_step,\\r\\n last_global_data_samples, **kwargs):\\r\\n checkpoint_state_dict = {\\r\\n 'epoch': epoch,\\r\\n 'last_global_step': last_global_step,\\r\\n 'last_global_data_samples': last_global_data_samples\\r\\n }\\r\\n # Add extra kwargs too\\r\\n checkpoint_state_dict.update(kwargs)\\r\\n\\r\\n success = model.network.save_checkpoint(PATH, ckpt_id,\\r\\n checkpoint_state_dict)\\r\\n status_msg = 'checkpointing: PATH={}, ckpt_id={}'.format(PATH, ckpt_id)\\r\\n if success:\\r\\n logging.info(f\\\"Success {status_msg}\\\")\\r\\n else:\\r\\n logging.warning(f\\\"Failure {status_msg}\\\")\\r\\n return\",\n \"def save_model(self, checkpoint_path, epoch):\\n self.saver.save(self.sess, checkpoint_path, global_step = epoch)\",\n \"def build_graph_from_config(self, model_config, track_config, checkpoint_path):\\n self.build_model()\\n \\n ema = tf.train.ExponentialMovingAverage(0)\\n variables_to_restore = ema.variables_to_restore(moving_avg_variables=[])\\n\\n # Filter out State variables\\n variables_to_restore_filterd = {}\\n for key, value in variables_to_restore.items():\\n if key.split('/')[1] != 'State':\\n if \\\"alex_branch\\\" not in key:\\n if \\\"vggf_branch\\\" not in key:\\n variables_to_restore_filterd[key] = value\\n \\n saver = tf.train.Saver(variables_to_restore_filterd)\\n \\n\\n if osp.isdir(checkpoint_path):\\n #checkpoint_path = tf.train.latest_checkpoint(checkpoint_path)\\n if not checkpoint_path:\\n raise ValueError(\\\"No checkpoint file found in: {}\\\".format(checkpoint_path))\\n\\n def _restore_fn(sess):\\n logging.info(\\\"Loading model from checkpoint: %s\\\", checkpoint_path)\\n saver.restore(sess, checkpoint_path)\\n logging.info(\\\"Successfully loaded checkpoint: %s\\\", os.path.basename(checkpoint_path))\\n logging.info(\\\"Restore CANet...\\\")\\n\\n return _restore_fn\",\n \"def load_model(self, model_path):\\n # Check the model file exists\\n if not os.path.isfile(model_path):\\n raise ValueError(f\\\"The model file `{model_path}` is not exists or broken!\\\")\\n\\n checkpoint = torch.load(model_path)\\n self.model_type = checkpoint['model_type']\\n self.label2idx = checkpoint['label2idx']\\n self.idx2label = checkpoint['idx2label']\\n self.model.load_state_dict(checkpoint['model_state_dict'])\\n self.model.to(self.device)\",\n \"def load_training_checkpoint(args, model, PATH, ckpt_id):\\r\\n logger = args.logger\\r\\n _, checkpoint_state_dict = model.network.load_checkpoint(PATH, ckpt_id)\\r\\n epoch = checkpoint_state_dict['epoch']\\r\\n last_global_step = checkpoint_state_dict['last_global_step']\\r\\n last_global_data_samples = checkpoint_state_dict[\\r\\n 'last_global_data_samples']\\r\\n del checkpoint_state_dict\\r\\n return (epoch, last_global_step, last_global_data_samples)\",\n \"def __init__(self, saved_model=None, serialize_input=True):\\n assert saved_model\\n self.saved_model_path = saved_model\\n self.serialize_input = serialize_input\\n logging.info(\\\"Reading checkpoint {}.\\\".format(saved_model))\\n imported_model = tf.saved_model.load(saved_model)\\n self.bleurt_model_ops = imported_model.signatures[\\\"serving_default\\\"]\\n logging.info(\\\"BLEURT initialized.\\\")\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(f\\\"Checkpoint '{checkpoint_path}' does not exist\\\")\\n\\n state = torch.load(checkpoint_path)\\n try:\\n model.load_state_dict(state['model_state_dict'])\\n except BaseException as e:\\n print('Failed to do something: ' + str(e))\\n\\n if optimizer is not None:\\n try:\\n optimizer.load_state_dict(state['optimizer_state_dict'])\\n except Exception as e:\\n print(e)\\n\\n return state\",\n \"def _init_model(\\n self,\\n cfg: ConfigType,\\n weights: Optional[str],\\n device: str = 'cpu',\\n ) -> nn.Module:\\n checkpoint: Optional[dict] = None\\n if weights is not None:\\n checkpoint = _load_checkpoint(weights, map_location='cpu')\\n\\n if not cfg:\\n assert checkpoint is not None\\n try:\\n # Prefer to get config from `message_hub` since `message_hub`\\n # is a more stable module to store all runtime information.\\n # However, the early version of MMEngine will not save config\\n # in `message_hub`, so we will try to load config from `meta`.\\n cfg_string = checkpoint['message_hub']['runtime_info']['cfg']\\n except KeyError:\\n assert 'meta' in checkpoint, (\\n 'If model(config) is not provided, the checkpoint must'\\n 'contain the config string in `meta` or `message_hub`, '\\n 'but both `meta` and `message_hub` are not found in the '\\n 'checkpoint.')\\n meta = checkpoint['meta']\\n if 'cfg' in meta:\\n cfg_string = meta['cfg']\\n else:\\n raise ValueError(\\n 'Cannot find the config in the checkpoint.')\\n cfg.update(\\n Config.fromstring(cfg_string, file_format='.py')._cfg_dict)\\n\\n # Delete the `pretrained` field to prevent model from loading the\\n # the pretrained weights unnecessarily.\\n if cfg.model.get('pretrained') is not None:\\n del cfg.model.pretrained\\n\\n model = MODELS.build(cfg.model)\\n model.cfg = cfg\\n self._load_weights_to_model(model, checkpoint, cfg)\\n model.to(device)\\n model.eval()\\n return model\",\n \"def load(self, checkpoint_dir):\\n print(\\\"\\\\nReading Checkpoints.....\\\\n\\\\n\\\")\\n model_dir = \\\"%s\\\" % (\\\"cnn\\\") # give the model name by label_size\\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir)\\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\\n \\n # Check the checkpoint is exist\\n if ckpt and ckpt.model_checkpoint_path:\\n ckpt_path = str(ckpt.model_checkpoint_path) # convert the unicode to string\\n self.saver.restore(self.sess, os.path.join(os.getcwd(), ckpt_path))\\n print(\\\"\\\\n Checkpoint Loading Success! %s\\\\n\\\\n\\\"% ckpt_path)\\n else:\\n print(\\\"\\\\n! Checkpoint Loading Failed \\\\n\\\\n\\\")\",\n \"def load_model(path='./model_checkpoint', name='tf_model'):\\n with open(os.path.join(path, name + '.json')) as json_file:\\n json_config = json_file.read()\\n model = TensorModel(tf.keras.models.model_from_json(json_config))\\n model._model.load_weights(os.path.join(path, name + '_weights.h5'))\\n\\n return model\",\n \"def try_create_model_load_from_checkpoint_and_adjust(self) -> bool:\\n success = self.try_create_model_and_load_from_checkpoint()\\n self.create_summary_and_adjust_model_for_gpus()\\n return success\",\n \"def load_model_from_checkpoint(file, device):\\r\\n\\r\\n if device == 'cuda':\\r\\n # Load all tensors onto GPU\\r\\n map_location = lambda storage, loc: storage.cuda()\\r\\n else:\\r\\n # Load all tensors onto CPU\\r\\n map_location = lambda storage, loc: storage\\r\\n\\r\\n # Assuming model was trained and checkpoint saved on Linux, but predict.py inference is executed using Windows.\\r\\n # Then, it is required to implement the following quick fix, because otherwise the exception is raised:\\r\\n # \\\"NotImplementedError: cannot instantiate 'PosixPath' on your system\\\"\\r\\n # Credits to https://stackoverflow.com/questions/57286486/i-cant-load-my-model-because-i-cant-put-a-posixpath\\r\\n if type(file) == pathlib.WindowsPath:\\r\\n tmp_PosixPath = pathlib.PosixPath\\r\\n pathlib.PosixPath = pathlib.WindowsPath\\r\\n\\r\\n parameters = torch.load(file, map_location=map_location)\\r\\n\\r\\n # Restore default\\r\\n if type(file) == pathlib.WindowsPath:\\r\\n pathlib.WindowsPath = pathlib.PosixPath\\r\\n pathlib.PosixPath = tmp_PosixPath\\r\\n\\r\\n model = train.create_model(parameters)\\r\\n\\r\\n model.class_to_idx = parameters.get('train_datasets_class_to_idx')\\r\\n model.load_state_dict(parameters.get('state_dict'), strict=False)\\r\\n\\r\\n return model, parameters\",\n \"def create_checkpoint(self, name, path=''):\\n\\n\\t\\tnb_path = self._get_os_path(name, path)\\n\\t\\tself.log.debug('creating checkpoint \\\"%s\\\" \\\"%s\\\" \\\"%s\\\"' % (path, name, nb_path))\\n\\t\\t# only the one checkpoint ID:\\n\\t\\tcheckpoint_id = u\\\"checkpoint\\\"\\n\\t\\tcp_path = self.get_checkpoint_path(checkpoint_id, name, path)\\n\\t\\tself.log.debug(\\\"creating checkpoint for notebook %s\\\", name)\\n\\t\\tif not key_exists(self.bucket, self.checkpoint_dir):\\n\\t\\t\\tnew_key_from_string(self.bucket, self.checkpoint_dir, '')\\n\\t\\tself._copy(nb_path, cp_path)\\n\\n\\t\\t# return the checkpoint info\\n\\t\\treturn self.get_checkpoint_model(checkpoint_id, name, path)\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(\\\"Checkpoint '{}' does not exist\\\".format(checkpoint_path))\\n\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else 'cpu')\\n state = torch.load(checkpoint_path, map_location=\\\"cuda:0\\\")\\n model.load_state_dict(state['model_state_dict'])\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(state['optimizer_state_dict'])\\n\\n return state\",\n \"def create_model(self):\\n try:\\n self.model = PPO2.load(self.save_path)\\n self.model.set_env(self.env)\\n print(\\\"Loading of the latest model successful!\\\")\\n except:\\n print(\\\"Creating new model...\\\")\\n self.model = PPO2(CnnPolicy, self.env, verbose=1)\",\n \"def _restore_checkpoint(self, checkpoint_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(checkpoint_path))\\n checkpoint = torch.load(checkpoint_path)\\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\\n \\n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\\n print('Parameters are inconsistant, adapting model parameters ...')\\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\\n del pretrained_dict['1']\\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\\n self.model.load_state_dict(model_dict)\\n else:\\n print('Parameters are consistant, load state dict directly ...')\\n self.model.load_state_dict(checkpoint['state_dict'])\\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\\n # if self.with_cuda:\\n # for state in self.optimizer.state.values():\\n # for k, v in state.items():\\n # if isinstance(v, torch.Tensor):\\n # state[k] = v.cuda(self.device)\",\n \"def load_model(config, batchmanager):\\n \\n # this function returns a dictionary mapping\\n # name of the task (string) --> number of classes in the task (int)\\n tasks = batchmanager.getTasksWithNClasses()\\n # this \\\"tasks\\\" object is used to initialize the model (with the right output layers)\\n model = MultiTaskBERT(device = config.device, tasks = tasks)\\n\\n if not config.untrained_baseline:\\n\\n # if we evaluate only, model MUST be loaded.\\n if config.k_shot_only:\\n try :\\n model.load_state_dict(torch.load(path_to_dicts(config), map_location = config.device))\\n except Exception:\\n print(f\\\"WARNING: the `--k_shot_only` flag was passed, but `{path_to_dicts(config)}` was NOT found!\\\")\\n raise Exception()\\n \\n # if we saved the state dictionary, load it.\\n elif config.resume:\\n try :\\n model.load_state_dict(torch.load(path_to_dicts(config), map_location = config.device))\\n except Exception:\\n print(f\\\"WARNING: the `--resume` flag was passed, but `{path_to_dicts(config)}` was NOT found!\\\")\\n else:\\n if os.path.exists(path_to_dicts(config)):\\n print(f\\\"WARNING: `--resume` flag was NOT passed, but `{path_to_dicts(config)}` was found!\\\") \\n\\n return model\",\n \"def load_checkpoints(args, model): \\n print('Loading the model checkpoints from iter {}...'.format(args.resume_iter))\\n checkpoint_path = os.path.join(config.checkpoint_path, args.model_type)\\n\\n gen_g_path = os.path.join(checkpoint_path, '{}-Gen_g.ckpt'.format(args.resume_iter))\\n gen_f_path = os.path.join(checkpoint_path, '{}-Gen_f.ckpt'.format(args.resume_iter))\\n model.gen_g.load_state_dict(torch.load(gen_g_path, map_location=lambda storage, loc: storage))\\n model.gen_f.load_state_dict(torch.load(gen_f_path, map_location=lambda storage, loc: storage))\\n\\n if args.train:\\n dis_c_path = os.path.join(checkpoint_path, '{}-Dis_c.ckpt'.format(args.resume_iter))\\n dis_t_path = os.path.join(checkpoint_path, '{}-Dis_t.ckpt'.format(args.resume_iter))\\n model.dis_c.load_state_dict(torch.load(dis_c_path, map_location=lambda storage, loc: storage))\\n model.dis_t.load_state_dict(torch.load(dis_t_path, map_location=lambda storage, loc: storage))\",\n \"def train(model_name, batch_size, steps_per_epoch, epochs, validation_steps, \\n model_file=None, save_path=None):\\n \\n print(\\\"- Loading configuration...\\\")\\n if model_name in models_default_params:\\n default_params = models_default_params[model_name]\\n else:\\n print(\\\"Error: the model '{}' has not been implemented\\\".format(model_name))\\n return\\n custom_objects = default_params['custom_objects']\\n patch_size = default_params['patch_size']\\n if save_path is None:\\n save_path = default_params['default_path']\\n if os.path.isfile(save_path):\\n print(\\\"Warning: {} is an existing file and will be overwritten.\\\".format(save_path))\\n print(\\\"- Configuration loaded.\\\")\\n \\n print(\\\"- Loading datasets...\\\")\\n train_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Training/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Training/Labels/\\\",\\n patch_size = patch_size)\\n val_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Validation/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Validation/Labels/\\\",\\n patch_size = patch_size)\\n print(\\\"- Data loaded.\\\")\\n \\n print(\\\"- Initialising model...\\\")\\n if(model_file is not None): # Further train existing model\\n model = keras.models.load_model(model_file, custom_objects=custom_objects)\\n else: # Create new model\\n if model_name == 'fcn':\\n model = fcn.make_fcn_resnet((patch_size, patch_size, channels), nb_labels, \\n use_pretraining=False, freeze_base=False)\\n elif model_name == 'pspnet':\\n model = pspnet.build_pspnet(nb_classes=nb_labels, resnet_layers=50,\\n input_shape=patch_size)\\n elif model_name == 'mobilenetv2':\\n model = mobilenetv2.MobileNetv2((patch_size, patch_size, channels), nb_labels) \\n\\n model.compile(\\n optimizer = optimizers.Adam(lr = 0.00001),\\n loss = losses.categorical_crossentropy,\\n metrics = [metrics.categorical_accuracy]) \\n model.summary() \\n print(\\\"- Model initialised.\\\")\\n \\n tensorboard = callbacks.TensorBoard(log_dir='./logs')\\n csv_logger = callbacks.CSVLogger('logs/training.csv')\\n checkpoint = callbacks.ModelCheckpoint(filepath=checkpoint_path,\\n save_weights_only=True,\\n save_best_only=True)\\n \\n print(\\\"- Starting training.\\\")\\n model.fit_generator(\\n generator=train_gen,\\n steps_per_epoch=steps_per_epoch,\\n epochs=epochs,\\n validation_data=val_gen,\\n validation_steps=validation_steps,\\n # callbacks=[checkpoint, csv_logger]\\n )\\n print(\\\"- Training complete.\\\")\\n \\n model.save(save_path)\\n print(\\\"- Model saved to {}\\\".format(save_path))\",\n \"def _setup_training(self, params, **kwargs):\\n model_params = params.permute_training_on_top().model\\n\\n model_kwargs = {**model_params.fixed, **model_params.variable}\\n\\n model = self.model_cls(**model_kwargs)\\n\\n training_params = params.permute_training_on_top().training\\n losses = training_params.nested_get(\\\"losses\\\")\\n optimizer_cls = training_params.nested_get(\\\"optimizer_cls\\\")\\n optimizer_params = training_params.nested_get(\\\"optimizer_params\\\")\\n train_metrics = training_params.nested_get(\\\"train_metrics\\\", {})\\n lr_scheduler_cls = training_params.nested_get(\\\"lr_sched_cls\\\", None)\\n lr_scheduler_params = training_params.nested_get(\\\"lr_sched_params\\\",\\n {})\\n val_metrics = training_params.nested_get(\\\"val_metrics\\\", {})\\n\\n # necessary for resuming training from a given path\\n save_path = kwargs.pop(\\\"save_path\\\", os.path.join(\\n self.save_path,\\n \\\"checkpoints\\\",\\n \\\"run_%02d\\\" % self._run))\\n\\n return self.trainer_cls(\\n network=model,\\n save_path=save_path,\\n losses=losses,\\n key_mapping=self.key_mapping,\\n optimizer_cls=optimizer_cls,\\n optimizer_params=optimizer_params,\\n train_metrics=train_metrics,\\n val_metrics=val_metrics,\\n lr_scheduler_cls=lr_scheduler_cls,\\n lr_scheduler_params=lr_scheduler_params,\\n optim_fn=self._optim_builder,\\n save_freq=self.checkpoint_freq,\\n **kwargs\\n )\",\n \"def load(self):\\n try:\\n if self.model.is_cuda:\\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \\\"save_point.pth\\\")))\\n else:\\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \\\\\\n \\\"save_point.pth\\\"), map_location=\\\"cpu\\\"))\\n except:\\n sys.exit(\\\"Unable to load previous model\\\")\",\n \"def train_and_eval(config, babas_data):\\n\\n if config.resume_from_checkpoint is not None:\\n try:\\n if config.augment_background == 'background':\\n bg = config.augment_background\\n else:\\n bg = None\\n rfc = config.resume_from_checkpoint\\n ic = config.include_validation\\n print 'Loading saved config: %s' % config.saved_config\\n config = np.load(config.saved_config).item()\\n config.resume_from_checkpoint = rfc\\n config.include_validation = ic\\n if not hasattr(config, 'augment_background'):\\n config.augment_background = 'constant'\\n if not hasattr(config, 'background_folder'):\\n config.background_folder = 'backgrounds'\\n if bg is not None:\\n print 'Overriding saved config to add kinect backgrounds to training.'\\n config.augment_background = bg\\n results_dir = rfc\\n except:\\n print 'Relying on default config file.'\\n\\n if babas_data: # Shitty naive training method\\n config.tfrecord_dir = '/media/data_cifs/monkey_tracking/data_for_babas/tfrecords_from_babas'\\n config.babas_tfrecord_dir = config.tfrecord_dir\\n config.steps_before_validation = 20\\n config.epochs = 2000\\n config.convert_labels_to_pixel_space = False\\n config.augment_background = 'constant'\\n\\n # Import your model\\n print 'Model directory: %s' % config.model_output\\n print 'Running model: %s' % config.model_type\\n model_file = import_cnn(config.model_type)\\n\\n # Prepare model training\\n dt_stamp = re.split(\\n '\\\\.', str(datetime.now()))[0].\\\\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\\n dt_dataset = '%s_%s' % (config.model_type, dt_stamp)\\n if config.selected_joints is not None:\\n dt_dataset = '_%s' % (config.selected_joints) + dt_dataset\\n config.train_checkpoint = os.path.join(\\n config.model_output, dt_dataset) # timestamp this run\\n config.summary_dir = os.path.join(\\n config.train_summaries, dt_dataset)\\n results_dir = os.path.join(config.npy_dir, dt_dataset)\\n print 'Saving Dmurphy\\\\'s online updates to: %s' % results_dir\\n dir_list = [config.train_checkpoint, config.summary_dir, results_dir]\\n [tf_fun.make_dir(d) for d in dir_list]\\n\\n # Prepare model inputs\\n train_data = os.path.join(config.tfrecord_dir, config.train_tfrecords)\\n if config.babas_tfrecord_dir is not None:\\n train_babas_tfrecord_dir = os.path.join(\\n config.babas_tfrecord_dir,\\n config.train_tfrecords)\\n if config.include_validation or config.include_validation is None:\\n val_babas_tfrecord_dir = os.path.join(\\n config.babas_tfrecord_dir,\\n config.val_tfrecords)\\n else:\\n train_babas_tfrecord_dir = None\\n val_babas_tfrecord_dir = None\\n\\n if isinstance(config.include_validation, basestring):\\n validation_data = config.include_validation\\n elif config.include_validation == True:\\n validation_data = os.path.join(\\n config.tfrecord_dir,\\n config.val_tfrecords)\\n else:\\n validation_data = None\\n\\n print 'Using training set: %s' % train_data\\n print 'Using validation set: %s' % validation_data\\n\\n # Prepare data on CPU\\n with tf.device('/cpu:0'):\\n train_data_dict = inputs(\\n tfrecord_file=train_data,\\n batch_size=config.train_batch,\\n im_size=config.resize,\\n target_size=config.image_target_size,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n label_shape=config.num_classes,\\n num_epochs=config.epochs,\\n image_target_size=config.image_target_size,\\n image_input_size=config.image_input_size,\\n maya_conversion=config.maya_conversion,\\n max_value=config.max_depth,\\n normalize_labels=config.normalize_labels,\\n aux_losses=config.aux_losses,\\n selected_joints=config.selected_joints,\\n joint_names=config.joint_order,\\n num_dims=config.num_dims,\\n keep_dims=config.keep_dims,\\n mask_occluded_joints=config.mask_occluded_joints,\\n background_multiplier=config.background_multiplier,\\n augment_background=config.augment_background,\\n background_folder=config.background_folder,\\n randomize_background=config.randomize_background,\\n maya_joint_labels=config.labels,\\n babas_tfrecord_dir=train_babas_tfrecord_dir,\\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\\n image_target_size_is_flipped=config.image_target_size_is_flipped)\\n train_data_dict['deconv_label_size'] = len(config.labels)\\n\\n val_data_dict = inputs(\\n tfrecord_file=validation_data,\\n batch_size=config.validation_batch,\\n im_size=config.resize,\\n target_size=config.image_target_size,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n label_shape=config.num_classes,\\n num_epochs=config.epochs,\\n image_target_size=config.image_target_size,\\n image_input_size=config.image_input_size,\\n maya_conversion=config.maya_conversion,\\n max_value=config.max_depth,\\n normalize_labels=config.normalize_labels,\\n aux_losses=config.aux_losses,\\n selected_joints=config.selected_joints,\\n joint_names=config.joint_order,\\n num_dims=config.num_dims,\\n keep_dims=config.keep_dims,\\n mask_occluded_joints=config.mask_occluded_joints,\\n background_multiplier=config.background_multiplier,\\n augment_background='none',\\n background_folder=config.background_folder,\\n randomize_background=None,\\n maya_joint_labels=config.labels,\\n babas_tfrecord_dir=val_babas_tfrecord_dir,\\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\\n image_target_size_is_flipped=config.image_target_size_is_flipped)\\n val_data_dict['deconv_label_size'] = len(config.labels)\\n\\n # Check output_shape\\n if config.selected_joints is not None:\\n print 'Targeting joint: %s' % config.selected_joints\\n joint_shape = len(config.selected_joints) * config.keep_dims\\n if (config.num_classes // config.keep_dims) > (joint_shape):\\n print 'New target size: %s' % joint_shape\\n config.num_classes = joint_shape\\n\\n with tf.device('/gpu:0'):\\n with tf.variable_scope('cnn') as scope:\\n print 'Creating training graph:'\\n model = model_file.model_struct(\\n weight_npy_path=config.weight_npy_path)\\n train_mode = tf.get_variable(name='training', initializer=True)\\n model.build(\\n rgb=train_data_dict['image'],\\n target_variables=train_data_dict,\\n train_mode=train_mode,\\n batchnorm=config.batch_norm)\\n train_mu, train_var = tf.nn.moments(train_data_dict['image'], axes=[1, 2, 3])\\n tf.summary.histogram(\\\"train image mean\\\", train_mu)\\n tf.summary.histogram(\\\"train image std\\\", tf.sqrt(train_var))\\n if 'deconv_image' in config.aux_losses:\\n tf.summary.image('Deconv train', model.deconv)\\n if 'deconv_label' in config.aux_losses:\\n tf.summary.image(\\n 'Deconv label train',\\n tf.expand_dims(\\n tf.cast(\\n tf.argmax(model.deconv, axis=3), tf.float32), 3))\\n\\n # Setup validation op\\n if validation_data is not False:\\n scope.reuse_variables()\\n print 'Creating validation graph:'\\n val_model = model_file.model_struct()\\n val_model.build(\\n rgb=val_data_dict['image'],\\n target_variables=val_data_dict)\\n\\n # Calculate validation accuracy\\n val_mu, val_var = tf.nn.moments(val_data_dict['image'], axes=[1, 2, 3])\\n tf.summary.histogram(\\\"validation image mean\\\", val_mu)\\n tf.summary.histogram(\\\"validation image std\\\", tf.sqrt(val_var))\\n if 'label' in val_data_dict.keys():\\n # val_score = tf.reduce_mean(\\n # tf_fun.l2_loss(\\n # val_model.output, val_data_dict['label']))\\n if config.keep_dims == 3:\\n z_mask = tf.expand_dims(tf.tile([1, 1, 0], [int(val_data_dict['label'].get_shape()[-1]) // 3]), axis=0)\\n z_mask = tf.cast(z_mask, tf.float32)\\n val_model.output = val_model.output * z_mask\\n val_data_dict['label'] = val_data_dict['label'] * z_mask \\n val_score = tf.reduce_mean(tf.nn.l2_loss(val_model.output - val_data_dict['label']))\\n tf.summary.scalar(\\\"validation mse\\\", val_score)\\n if 'fc' in config.aux_losses:\\n tf.summary.image('FC val activations', val_model.final_fc)\\n if 'deconv_image' in config.aux_losses:\\n tf.summary.image('Deconv val', val_model.deconv)\\n if 'deconv_label' in config.aux_losses:\\n tf.summary.image(\\n 'Deconv label train',\\n tf.expand_dims(\\n tf.cast(\\n tf.argmax(val_model.deconv, axis=3),\\n tf.float32), 3))\\n tf.summary.image(\\n 'validation images',\\n tf.cast(val_data_dict['image'], tf.float32))\\n\\n # Prepare the loss functions:::\\n loss_list, loss_label = [], []\\n if 'label' in train_data_dict.keys():\\n # 1. Joint localization loss\\n if config.calculate_per_joint_loss == 'thomas':\\n label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\\n model=model,\\n train_data_dict=train_data_dict,\\n config=config,\\n y_key='label',\\n yhat_key='output')\\n loss_list += [label_loss]\\n elif config.calculate_per_joint_loss == 'skeleton':\\n label_loss = tf_fun.skeleton_loss(\\n model=model,\\n train_data_dict=train_data_dict,\\n config=config,\\n y_key='label',\\n yhat_key='output')\\n loss_list += [label_loss]\\n elif config.calculate_per_joint_loss == 'skeleton and joint':\\n label_loss = tf_fun.skeleton_loss(\\n model=model,\\n train_data_dict=train_data_dict,\\n config=config,\\n y_key='label',\\n yhat_key='output')\\n loss_list += [label_loss]\\n loss_label += ['skeleton loss']\\n delta = model['output'] - train_data_dict['label']\\n proc_weights = np.asarray(\\n config.dim_weight)[None,:].repeat(\\n len(config.joint_names), axis=0).reshape(1, -1)\\n delta *= proc_weights\\n # label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\\n # model=model,\\n # train_data_dict=train_data_dict,\\n # config=config,\\n # y_key='label',\\n # yhat_key='output')\\n # loss_list += [label_loss]\\n loss_list += [tf.nn.l2_loss(\\n model['output'] - train_data_dict['label'])]\\n else:\\n loss_list += [tf.nn.l2_loss(\\n model['output'] - train_data_dict['label'])]\\n loss_label += ['combined head']\\n for al in loss_helper.potential_aux_losses():\\n loss_list, loss_label = loss_helper.get_aux_losses(\\n loss_list=loss_list,\\n loss_label=loss_label,\\n train_data_dict=train_data_dict,\\n model=model,\\n aux_loss_dict=al,\\n domain_adaptation=train_babas_tfrecord_dir)\\n loss = tf.add_n(loss_list)\\n\\n # Add wd if necessary\\n if config.wd_penalty is not None:\\n _, l2_wd_layers = tf_fun.fine_tune_prepare_layers(\\n tf.trainable_variables(), config.wd_layers)\\n l2_wd_layers = [\\n x for x in l2_wd_layers if 'biases' not in x.name]\\n if config.wd_type == 'l1':\\n loss += (config.wd_penalty * tf.add_n(\\n [tf.reduce_sum(tf.abs(x)) for x in l2_wd_layers]))\\n elif config.wd_type == 'l2':\\n loss += (config.wd_penalty * tf.add_n(\\n [tf.nn.l2_loss(x) for x in l2_wd_layers]))\\n\\n optimizer = loss_helper.return_optimizer(config.optimizer)\\n optimizer = optimizer(config.lr)\\n\\n if hasattr(config, 'fine_tune_layers') and config.fine_tune_layers is not None:\\n print 'Finetuning learning for: %s' % config.fine_tune_layers\\n train_op, grads = tf_fun.finetune_learning(\\n loss,\\n trainables=tf.trainable_variables(),\\n fine_tune_layers=config.fine_tune_layers,\\n config=config\\n )\\n else:\\n # Op to calculate every variable gradient\\n grads = optimizer.compute_gradients(\\n loss, tf.trainable_variables())\\n # Op to update all variables according to their gradient\\n train_op = optimizer.apply_gradients(\\n grads_and_vars=grads)\\n\\n # Summarize all gradients and weights\\n [tf.summary.histogram(\\n var.name + '/gradient', grad)\\n for grad, var in grads if grad is not None]\\n # train_op = optimizer.minimize(loss)\\n\\n # Summarize losses\\n [tf.summary.scalar(lab, il) for lab, il in zip(\\n loss_label, loss_list)]\\n\\n # Summarize images and l1 weights\\n tf.summary.image(\\n 'train images',\\n tf.cast(train_data_dict['image'], tf.float32))\\n tf_fun.add_filter_summary(\\n trainables=tf.trainable_variables(),\\n target_layer='conv1_1_filters')\\n\\n # Set up summaries and saver\\n saver = tf.train.Saver(\\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\\n summary_op = tf.summary.merge_all()\\n tf.add_to_collection('output', model.output)\\n\\n # Initialize the graph\\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\\n\\n # Need to initialize both of these if supplying num_epochs to inputs\\n sess.run(tf.group(tf.global_variables_initializer(),\\n tf.local_variables_initializer()))\\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\\n\\n # Set up exemplar threading\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\\n\\n # Create list of variables to run through training model\\n train_session_vars = {\\n 'train_op': train_op,\\n 'loss_value': loss,\\n 'im': train_data_dict['image'],\\n 'yhat': model.output,\\n 'ytrue': train_data_dict['label']\\n }\\n if hasattr(model, 'deconv'):\\n train_session_vars['deconv'] = model.deconv\\n if hasattr(model, 'final_fc'):\\n train_session_vars['fc'] = model.final_fc\\n\\n # Create list of variables to run through validation model\\n val_session_vars = {\\n 'val_acc': val_score,\\n 'val_pred': val_model.output,\\n 'val_ims': val_data_dict['image'],\\n 'val_true': val_data_dict['label'],\\n }\\n\\n # Create list of variables to save to numpys\\n save_training_vars = [\\n 'im',\\n 'yhat',\\n 'ytrue',\\n 'yhat'\\n ]\\n\\n for al in loss_helper.potential_aux_losses():\\n if al.keys()[0] in train_data_dict.keys():\\n y_key = '%s' % al.keys()[0]\\n train_session_vars[y_key] = train_data_dict[al.values()[0]['y_name']]\\n save_training_vars += [y_key]\\n\\n yhat_key = '%s_hat' % al.keys()[0]\\n train_session_vars[yhat_key] = model[al.values()[0]['model_name']]\\n save_training_vars += [yhat_key]\\n\\n # Start training loop\\n np.save(config.train_checkpoint, config)\\n step, losses = 0, []\\n num_joints = int(\\n train_data_dict['label'].get_shape()[-1]) // config.keep_dims\\n normalize_vec = tf_fun.get_normalization_vec(config, num_joints)\\n if config.resume_from_checkpoint is not None:\\n if '.ckpt' in config.resume_from_checkpoint:\\n ckpt = config.resume_from_checkpoint\\n 'Restoring specified checkpoint: %s' % config.resume_from_checkpoint\\n else:\\n ckpt = tf.train.latest_checkpoint(config.resume_from_checkpoint)\\n print 'Evaluating checkpoint: %s' % ckpt\\n saver.restore(sess, ckpt)\\n try:\\n while not coord.should_stop():\\n start_time = time.time()\\n train_out_dict = sess.run(train_session_vars.values())\\n train_out_dict = {k: v for k, v in zip(\\n train_session_vars.keys(), train_out_dict)}\\n losses.append(train_out_dict['loss_value'])\\n duration = time.time() - start_time\\n assert not np.isnan(\\n train_out_dict['loss_value']), 'Model diverged with loss = NaN'\\n if step % config.steps_before_validation == 0:\\n if validation_data is not False:\\n val_out_dict = sess.run(\\n val_session_vars.values())\\n val_out_dict = {k: v for k, v in zip(\\n val_session_vars.keys(), val_out_dict)}\\n # if config.normalize_labels:\\n # val_out_dict['val_pred'] *= normalize_vec\\n # val_out_dict['val_true'] *= normalize_vec\\n np.savez(\\n os.path.join(\\n results_dir, '%s_val_coors' % step),\\n val_pred=val_out_dict['val_pred'],\\n val_ims=val_out_dict['val_ims'],\\n val_true=val_out_dict['val_true'],\\n normalize_vec=normalize_vec)\\n with open(\\n os.path.join(\\n results_dir, '%s_config.p' % step), 'wb') as fp:\\n pickle.dump(config, fp)\\n\\n # Summaries\\n summary_str = sess.run(summary_op)\\n summary_writer.add_summary(summary_str, step)\\n\\n # Training status and validation accuracy attach 9177\\n format_str = (\\n '%s: step %d, loss = %.8f (%.1f examples/sec; '\\n '%.3f sec/batch) | '\\n 'Validation l2 loss = %s | logdir = %s')\\n print (format_str % (\\n datetime.now(), step, train_out_dict['loss_value'],\\n config.train_batch / duration, float(duration),\\n val_out_dict['val_acc'],\\n config.summary_dir))\\n\\n # Save the model checkpoint if it's the best yet\\n if config.normalize_labels:\\n train_out_dict['yhat'] *= normalize_vec\\n train_out_dict['ytrue'] *= normalize_vec\\n [save_training_data(\\n output_dir=results_dir,\\n data=train_out_dict[k],\\n name='%s_%s' % (k, step)) for k in save_training_vars]\\n saver.save(\\n sess, os.path.join(\\n config.train_checkpoint,\\n 'model_' + str(step) + '.ckpt'), global_step=step)\\n\\n else:\\n # Training status\\n format_str = ('%s: step %d, loss = %.8f (%.1f examples/sec; '\\n '%.3f sec/batch)')\\n print (format_str % (\\n datetime.now(),\\n step,\\n train_out_dict['loss_value'],\\n config.train_batch / duration,\\n float(duration)))\\n # End iteration\\n step += 1\\n\\n except tf.errors.OutOfRangeError:\\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\\n finally:\\n coord.request_stop()\\n dt_stamp = get_dt() # date-time stamp\\n np.save(\\n os.path.join(\\n config.tfrecord_dir, '%s_training_loss' % dt_stamp), losses)\\n coord.join(threads)\\n sess.close()\",\n \"def load_ckp(checkpoint_fpath, model, optimizer, device):\\n\\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\\n model.load_state_dict(checkpoint['state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n valid_acc = checkpoint['valid_acc'] \\n return model, optimizer, checkpoint['epoch'], valid_acc\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n model_state_dict, optimizer_state_dict = torch.load(checkpoint)\\n model.load_state_dict(model_state_dict)\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(optimizer_state_dict)\",\n \"def load_epoch_checkpoint(self, directory, epoch):\\n chkpnt = torch.load(directory / f\\\"chkpnt_epoch{epoch:04d}.pth\\\")\\n self.load_state_dict(chkpnt['model_state_dict'])\",\n \"def __init__(self, model_dir: str, *args, **kwargs):\\n super().__init__(model_dir, *args, **kwargs)\\n self.model = FRCRN(*args, **kwargs)\\n model_bin_file = os.path.join(model_dir,\\n ModelFile.TORCH_MODEL_BIN_FILE)\\n if os.path.exists(model_bin_file):\\n checkpoint = torch.load(\\n model_bin_file, map_location=torch.device('cpu'))\\n if isinstance(checkpoint, dict) and 'state_dict' in checkpoint:\\n # the new trained model by user is based on FRCRNDecorator\\n self.load_state_dict(checkpoint['state_dict'])\\n else:\\n # The released model on Modelscope is based on FRCRN\\n self.model.load_state_dict(checkpoint, strict=False)\",\n \"def load_checkpoint(self, checkpoint: str, **kwargs) -> None:\\n with open(checkpoint, \\\"rb\\\") as f:\\n state = SafePickle.load(f)\\n\\n state_id = ray.put(state)\\n ray.get([worker.set_state.remote(state_id, **kwargs) for worker in self.remote_workers])\",\n \"def load_model(self):\\n if self.ckpt_flag:\\n LOG('Skip Loading Pre-trained Model......')\\n else:\\n if self.params.pre_trained_from is not None and os.path.exists(self.params.pre_trained_from):\\n try:\\n LOG('Loading Pre-trained Model at %s' % self.params.pre_trained_from)\\n pretrain = torch.load(self.params.pre_trained_from)\\n self.network.load_state_dict(pretrain)\\n LOG('Pre-trained Model Loaded!')\\n except:\\n WARNING('Cannot load pre-trained model. Start training......')\\n else:\\n WARNING('Pre-trained model do not exits. Start training......')\",\n \"def _load_checkpoint(cls, model: DeviceAwareModule, checkpoint_path: Path,\\n key_in_state_dict: str, use_gpu: bool) -> int:\\n logging.info(f\\\"Loading checkpoint {checkpoint_path}\\\")\\n checkpoint = ModelAndInfo.read_checkpoint(checkpoint_path, use_gpu)\\n\\n try:\\n state_dict = checkpoint[key_in_state_dict]\\n except KeyError:\\n logging.error(f\\\"Key {key_in_state_dict} not found in checkpoint\\\")\\n return False\\n\\n if isinstance(model, torch.nn.DataParallel):\\n result = model.module.load_state_dict(state_dict, strict=False)\\n else:\\n result = model.load_state_dict(state_dict, strict=False)\\n\\n if result.missing_keys:\\n logging.warning(f\\\"Missing keys in model checkpoint: {result.missing_keys}\\\")\\n if result.unexpected_keys:\\n logging.warning(f\\\"Unexpected keys in model checkpoint: {result.unexpected_keys}\\\")\\n\\n return checkpoint[ModelAndInfo.EPOCH_KEY]\",\n \"def setup_training(model, train_loader, valid_loader, hps):\\r\\n\\r\\n train_dir = os.path.join(hps.save_root, \\\"train\\\")\\r\\n if not os.path.exists(train_dir): os.makedirs(train_dir)\\r\\n\\r\\n if hps.restore_model != 'None':\\r\\n logger.info(\\\"[INFO] Restoring %s for training...\\\", hps.restore_model)\\r\\n bestmodel_file = os.path.join(train_dir, hps.restore_model)\\r\\n loader = ModelLoader()\\r\\n loader.load_pytorch(model, bestmodel_file)\\r\\n else:\\r\\n logger.info(\\\"[INFO] Create new model for training...\\\")\\r\\n\\r\\n run_training(model, train_loader, valid_loader, hps) # this is an infinite loop until interrupted\\r\",\n \"def load_checkpoint(self, model, optimizers):\\n self.epoch = get_last_epoch(self.log_path)\\n\\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\\n model.load_state_dict(model_state_dict)\\n\\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\\n for opt_ind in range(len(optimizers)):\\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\\n\\n schedulers = load_sched(optimizers, self.epoch)\\n\\n return model, optimizers, schedulers\",\n \"def try_and_init_from(self, path):\\n log.info(\\\"Loading weights from foreign checkpoint {}\\\".format(path))\\n if not os.path.exists(path):\\n raise ValueError(\\\"Checkpoint {} does not exist\\\".format(path))\\n\\n chkpt = th.load(path, map_location=th.device(\\\"cpu\\\"))\\n if \\\"model\\\" not in chkpt.keys() or chkpt[\\\"model\\\"] is None:\\n raise ValueError(\\\"{} has no model saved\\\".format(path))\\n\\n mdl = chkpt[\\\"model\\\"]\\n for n, p in self.model.named_parameters():\\n if n in mdl:\\n p2 = mdl[n]\\n if p2.shape != p.shape:\\n log.warning(\\\"Parameter {} ignored, checkpoint size does not match: {}, should be {}\\\".format(n, p2.shape, p.shape))\\n continue\\n log.debug(\\\"Parameter {} copied\\\".format(n))\\n p.data.copy_(p2)\\n else:\\n log.warning(\\\"Parameter {} ignored, not found in source checkpoint.\\\".format(n))\\n\\n log.info(\\\"Weights loaded from foreign checkpoint {}\\\".format(path))\",\n \"def _save_model(self, checkpoint_dir):\\n # Check whether the specified path exists or not\\n isExist = os.path.exists(checkpoint_dir)\\n\\n if not isExist:\\n # Create a new directory because it does not exist\\n os.makedirs(checkpoint_dir)\\n\\n filename = self._get_checkpoint_name()\\n path = checkpoint_dir + filename\\n\\n # Serialize the model checkpoint in to a Python Pickle file\\n with open(path, 'wb') as f:\\n pickle.dump(self._model, f)\\n return path\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77202636","0.7588646","0.7440869","0.7204906","0.71627265","0.7153112","0.7153112","0.7096752","0.7063371","0.7042817","0.7034828","0.6975058","0.69707805","0.69557154","0.69152653","0.6887786","0.6820848","0.68042725","0.67946786","0.6771584","0.6762465","0.675391","0.67403316","0.6708518","0.6686366","0.66816217","0.6679283","0.66758716","0.6670577","0.6657054","0.6651751","0.6651429","0.66511196","0.6647377","0.6644745","0.6636243","0.6636181","0.6630305","0.6626725","0.6623121","0.66225934","0.6618249","0.6616538","0.66093624","0.66044694","0.65970784","0.65946275","0.6587542","0.6585933","0.6574459","0.65616167","0.6557188","0.65475404","0.6543599","0.6537196","0.6535007","0.65204644","0.6514639","0.6513976","0.65099424","0.65099126","0.65099126","0.64938927","0.64918244","0.64895964","0.6488237","0.64868593","0.64865357","0.6480784","0.64773977","0.6466501","0.64652777","0.6453639","0.6448046","0.6445826","0.6429533","0.6419853","0.6418043","0.64152324","0.6408688","0.6391328","0.6379987","0.6373571","0.63657904","0.6355582","0.6334412","0.63329536","0.6322521","0.63189983","0.6312858","0.6305118","0.6300038","0.62980545","0.6296586","0.62689227","0.6256852","0.6245888","0.6243168","0.6242567","0.6239272","0.62377995"],"string":"[\n \"0.77202636\",\n \"0.7588646\",\n \"0.7440869\",\n \"0.7204906\",\n \"0.71627265\",\n \"0.7153112\",\n \"0.7153112\",\n \"0.7096752\",\n \"0.7063371\",\n \"0.7042817\",\n \"0.7034828\",\n \"0.6975058\",\n \"0.69707805\",\n \"0.69557154\",\n \"0.69152653\",\n \"0.6887786\",\n \"0.6820848\",\n \"0.68042725\",\n \"0.67946786\",\n \"0.6771584\",\n \"0.6762465\",\n \"0.675391\",\n \"0.67403316\",\n \"0.6708518\",\n \"0.6686366\",\n \"0.66816217\",\n \"0.6679283\",\n \"0.66758716\",\n \"0.6670577\",\n \"0.6657054\",\n \"0.6651751\",\n \"0.6651429\",\n \"0.66511196\",\n \"0.6647377\",\n \"0.6644745\",\n \"0.6636243\",\n \"0.6636181\",\n \"0.6630305\",\n \"0.6626725\",\n \"0.6623121\",\n \"0.66225934\",\n \"0.6618249\",\n \"0.6616538\",\n \"0.66093624\",\n \"0.66044694\",\n \"0.65970784\",\n \"0.65946275\",\n \"0.6587542\",\n \"0.6585933\",\n \"0.6574459\",\n \"0.65616167\",\n \"0.6557188\",\n \"0.65475404\",\n \"0.6543599\",\n \"0.6537196\",\n \"0.6535007\",\n \"0.65204644\",\n \"0.6514639\",\n \"0.6513976\",\n \"0.65099424\",\n \"0.65099126\",\n \"0.65099126\",\n \"0.64938927\",\n \"0.64918244\",\n \"0.64895964\",\n \"0.6488237\",\n \"0.64868593\",\n \"0.64865357\",\n \"0.6480784\",\n \"0.64773977\",\n \"0.6466501\",\n \"0.64652777\",\n \"0.6453639\",\n \"0.6448046\",\n \"0.6445826\",\n \"0.6429533\",\n \"0.6419853\",\n \"0.6418043\",\n \"0.64152324\",\n \"0.6408688\",\n \"0.6391328\",\n \"0.6379987\",\n \"0.6373571\",\n \"0.63657904\",\n \"0.6355582\",\n \"0.6334412\",\n \"0.63329536\",\n \"0.6322521\",\n \"0.63189983\",\n \"0.6312858\",\n \"0.6305118\",\n \"0.6300038\",\n \"0.62980545\",\n \"0.6296586\",\n \"0.62689227\",\n \"0.6256852\",\n \"0.6245888\",\n \"0.6243168\",\n \"0.6242567\",\n \"0.6239272\",\n \"0.62377995\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":4478,"cells":{"query":{"kind":"string","value":"Creates a model as per the config, and loads the parameters from the given checkpoint path. The model is then adjusted for data parallelism and mixed precision. Also updates the checkpoint_epoch."},"document":{"kind":"string","value":"def try_create_mean_teacher_model_load_from_checkpoint_and_adjust(self) -> bool:\n success = self.try_create_mean_teacher_model_and_load_from_checkpoint()\n self.create_summary_and_adjust_mean_teacher_model_for_gpus()\n return success"},"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 load(self, model_path):\n # TODO: include new params based on ConfigEnum\n checkpoint = torch.load(model_path)\n\n self.image_size = checkpoint['image_size']\n self.device = checkpoint['device']\n self.fp16 = checkpoint['fp16']\n self.accumulate_grad_steps = checkpoint['accumulate_grad_steps']\n self.experiment_id = checkpoint['experiment_id']\n self.experiment_tag = checkpoint['experiment_tag']\n self.seed = checkpoint['seed']\n self.train_batch_size = checkpoint['train_batch_size']\n self.valid_batch_size = checkpoint['valid_batch_size']\n self.test_batch_size = checkpoint['test_batch_size']\n self.dataloader_num_workers = checkpoint['dataloader_num_workers']\n self.train_dataloader_shuffle = checkpoint['train_dataloader_shuffle']\n self.optimizer_type = checkpoint['optimizer_type']\n self.optimizer_params = checkpoint['optimizer_params']\n self.scheduler_type = checkpoint['scheduler_type']\n self.scheduler_params = checkpoint['scheduler_params']\n self.step_scheduler_after = checkpoint['step_scheduler_after']\n self.step_scheduler_metric = checkpoint['step_scheduler_metric']\n self.compute_train_loss_after = checkpoint['compute_train_loss_after']\n self.compute_train_metric_after = checkpoint['compute_train_metric_after']\n self.compute_valid_loss_after = checkpoint['compute_valid_loss_after']\n self.compute_valid_metric_after = checkpoint['compute_valid_metric_after']\n self.training_stopping_criteria = checkpoint['training_stopping_criteria']\n self.stopping_criteria_params = checkpoint['stopping_criteria_params']\n self.max_epoch = checkpoint['max_epoch']\n self.train_on_all_data = checkpoint['train_on_all_data']\n self.validate_after = checkpoint['validate_after']\n self.validation_steps = checkpoint['validation_steps']\n self.run_lr_range_test= checkpoint['run_lr_range_test']\n self.sleep_in_epochs = checkpoint['sleep_in_epochs']\n self.sleep_time = checkpoint['sleep_time']\n self.checkpoint_epochs = checkpoint['checkpoint_epochs']\n\n self._best_score = checkpoint['_best_score']\n self._current_score = checkpoint['_current_score']\n self._counter = checkpoint['_counter']\n self.metrics = checkpoint['metrics']\n self.current_epoch = checkpoint['current_epoch']\n self.current_train_batch = checkpoint['current_train_batch']\n self.current_valid_batch = checkpoint['current_valid_batch']\n self.num_train_samples = checkpoint['num_train_samples']\n self.num_train_iterations = checkpoint['num_train_iterations']\n self.checkpoint_snapshot = checkpoint['checkpoint_snapshot'] \n\n # initialize optimizer, scheduler, and gradient scaler\n self.configure_optimizers()\n self.configure_schedulers()\n \n if self.fp16:\n self.scaler = torch.cuda.amp.GradScaler()\n\n if self.model:\n self.model.load_state_dict(checkpoint['state_dict'])\n self.model.to(self.device)\n\n if self.optimizer:\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n if self.scheduler:\n self.scheduler.load_state_dict(checkpoint['scheduler'])\n\n #if self.scaler:\n # self.scaler.load_state_dict(checkpoint['scaler'])","def load_model(self, checkpoint):\n print(f'Load parameters from {checkpoint}')\n epoch = re.match(r\"[0-9]*\", os.path.basename(checkpoint)).group(0)\n self.epoch_i = int(epoch)\n self.model.load_state_dict(torch.load(checkpoint))","def save_checkpoint(self, model_path=None):\n # TODO: include new params based on ConfigEnum\n if not os.path.isdir(path_checkpoints_dir):\n os.mkdir(path_checkpoints_dir)\n if model_path is None:\n model_path = os.path.join(path_checkpoints_dir, f\"{self.experiment_id}.pth\")\n print(f\"saved the model at {model_path}\") \n model_state_dict = self.model.state_dict()\n if self.optimizer is not None:\n opt_state_dict = self.optimizer.state_dict()\n else:\n opt_state_dict = None\n if self.scheduler is not None:\n sch_state_dict = self.scheduler.state_dict()\n else:\n sch_state_dict = None\n \n if self.scaler is not None:\n amp_grad_scaler = self.scaler.state_dict()\n else:\n amp_grad_scaler = None\n\n model_dict = {}\n model_dict[\"state_dict\"] = model_state_dict\n model_dict[\"optimizer\"] = opt_state_dict\n model_dict[\"scheduler\"] = sch_state_dict\n model_dict['scaler'] = amp_grad_scaler\n model_dict['image_size'] = self.image_size\n model_dict['device'] = self.device\n model_dict['fp16'] = self.fp16\n model_dict['accumulate_grad_steps'] = self.accumulate_grad_steps\n\n model_dict['experiment_id'] = self.experiment_id\n model_dict['experiment_tag'] = self.experiment_tag\n\n model_dict['seed'] = self.seed\n\n model_dict['train_batch_size'] = self.train_batch_size\n model_dict['valid_batch_size'] = self.valid_batch_size\n model_dict['test_batch_size'] = self.test_batch_size\n model_dict['dataloader_num_workers'] = self.dataloader_num_workers\n model_dict['train_dataloader_shuffle'] = self.train_dataloader_shuffle\n\n model_dict['optimizer_type'] = self.optimizer_type\n model_dict['optimizer_params'] = self.optimizer_params\n\n model_dict['scheduler_type'] = self.scheduler_type\n model_dict['scheduler_params'] = self.scheduler_params\n model_dict['step_scheduler_after'] = self.step_scheduler_after\n model_dict['step_scheduler_metric'] = self.step_scheduler_metric\n\n model_dict['compute_train_loss_after'] = self.compute_train_loss_after\n model_dict['compute_train_metric_after'] = self.compute_train_metric_after\n model_dict['compute_valid_loss_after'] = self.compute_valid_loss_after\n model_dict['compute_valid_metric_after'] = self.compute_valid_metric_after\n\n model_dict['training_stopping_criteria'] = self.training_stopping_criteria\n model_dict['stopping_criteria_params'] = self.stopping_criteria_params\n model_dict['max_epoch'] = self.max_epoch\n model_dict['train_on_all_data'] = self.train_on_all_data\n model_dict['validate_after'] = self.validate_after\n model_dict['validation_steps'] = self.validation_steps\n model_dict['run_lr_range_test'] = self.run_lr_range_test\n model_dict['sleep_in_epochs'] = self.sleep_in_epochs\n model_dict['sleep_time'] = self.sleep_time\n model_dict['checkpoint_epochs'] = self.checkpoint_epochs\n\n model_dict['_best_score'] = self._best_score\n model_dict['_current_score'] = self._current_score\n model_dict['_counter'] = self._counter\n\n model_dict['metrics'] = self.metrics\n model_dict['current_epoch'] = self.current_epoch\n model_dict['current_train_batch'] = self.current_train_batch\n model_dict['current_valid_batch'] = self.current_valid_batch\n\n model_dict['num_train_samples'] = self.num_train_samples\n model_dict['num_train_iterations'] = self.num_train_iterations\n model_dict['checkpoint_snapshot'] = self.checkpoint_snapshot \n torch.save(model_dict, model_path)","def create_checkpoint(model_config, path):\n model = models.VisionTransformer(num_classes=1, **model_config)\n variables = model.init(\n jax.random.PRNGKey(0),\n jnp.ones([1, 16, 16, 3], jnp.float32),\n train=False,\n )\n _save(variables['params'], path)","def init_model(config, program, exe):\n checkpoints = config['Global'].get('checkpoints')\n if checkpoints:\n if os.path.exists(checkpoints + '.pdparams'):\n path = checkpoints\n fluid.load(program, path, exe)\n logger.info(\"Finish initing model from {}\".format(path))\n else:\n raise ValueError(\"Model checkpoints {} does not exists,\"\n \"check if you lost the file prefix.\".format(\n checkpoints + '.pdparams'))\n else:\n pretrain_weights = config['Global'].get('pretrain_weights')\n if pretrain_weights:\n path = pretrain_weights\n load_params(exe, program, path)\n logger.info(\"Finish initing model from {}\".format(path))","def load_model(self, ckpt_fn):\n checkpoint = torch.load(ckpt_fn)\n self.net_.load_state_dict(checkpoint[\"model\"])\n self.optimizer_.load_state_dict(checkpoint[\"optimizer\"])\n self.epoch_ = checkpoint[\"epoch\"]\n self.global_step_ = checkpoint[\"global_step\"]\n self.model_samples_ = deque(checkpoint[\"model_samples\"])\n self.sampler.load_state_dict(checkpoint[\"sampler_state\"])\n self.ais_loss.load_state_dict(checkpoint[\"ais_state\"])\n self.replay_prob = checkpoint[\"replay_prob\"]\n self.max_replay = checkpoint[\"max_replay\"]","def load_checkpoint(path):\n\n # Get the model name\n model_name = path.split('-')[0]\n assert (model_name in ['vgg16', 'resnet50'\n ]), \"Path must have the correct model name\"\n\n # Load in checkpoint\n checkpoint = torch.load(path)\n\n if model_name == 'vgg16':\n model = models.vgg16(pretrained=True)\n # Make sure to set parameters as not trainable\n for param in model.parameters():\n param.requires_grad = False\n model.classifier = checkpoint['classifier']\n\n elif model_name == 'resnet50':\n model = models.resnet50(pretrained=True)\n # Make sure to set parameters as not trainable\n for param in model.parameters():\n param.requires_grad = False\n model.fc = checkpoint['fc']\n\n # Load in the state dict\n model.load_state_dict(checkpoint['state_dict'])\n\n total_params = sum(p.numel() for p in model.parameters())\n print(f'{total_params:,} total parameters.')\n total_trainable_params = sum(\n p.numel() for p in model.parameters() if p.requires_grad)\n print(f'{total_trainable_params:,} total gradient parameters.')\n\n # Move to gpu\n if multi_gpu:\n model = nn.DataParallel(model)\n\n if train_on_gpu:\n model = model.to('cuda')\n\n # Model basics\n model.class_to_idx = checkpoint['class_to_idx']\n model.idx_to_class = checkpoint['idx_to_class']\n model.epochs = checkpoint['epochs']\n\n # Optimizer\n optimizer = checkpoint['optimizer']\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n\n return model, optimizer","def load(cls, model_path: str, sample_shape: tuple = None,\n checkpoint: str = None, **kwargs):","def maybe_load_model(name, split_num, checkpoint_dir, resume_from_epoch,\n batch_norm, l1_factor, l2_factor, optimizer):\n basename = get_basename(name, split_num)\n model_filename_fmt = get_model_filename_fmt(basename)\n model_filename = model_filename_fmt.format(epoch=resume_from_epoch)\n\n checkpoint_path = os.path.join(checkpoint_dir, model_filename)\n\n if resume_from_epoch > 0 and os.path.isfile(checkpoint_path):\n\n click.secho(f\"Found model checkpoint '{checkpoint_path}'. \"\n f\"Resuming from epoch {resume_from_epoch}.\", fg='green')\n\n model = load_model(checkpoint_path)\n\n initial_epoch = resume_from_epoch\n\n else:\n\n click.secho(f\"Could not load model checkpoint '{checkpoint_path}' \"\n \"or `resume_from_epoch == 0`. Building new model.\",\n fg='yellow')\n\n model = build_model(output_dim=1, batch_norm=batch_norm,\n kernel_regularizer=l1_l2(l1_factor, l2_factor))\n # optimizer = Adam(beta_1=0.5)\n model.compile(loss='binary_crossentropy', optimizer=optimizer,\n metrics=['accuracy'])\n\n initial_epoch = 0\n\n return model, initial_epoch","def load_model_from_checkpoint(self, path: str):\n ckpt = torch.load(path, map_location='cpu')\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\n self.net_q.head.load_state_dict(ckpt['head'])\n self.net_ps.load_state_dict(ckpt['net_ps'])\n self.net_k.load_state_dict(ckpt['net_k'])\n self.queue.load_state_dict(ckpt['queue'])\n self.optimizer.load_state_dict(ckpt['optimizer'])\n if 'scheduler' in ckpt:\n self.scheduler.load_stae_dict(ckpt['scheduler'])\n self.move_optimizer_states(self.optimizer, self.local_rank)","def load_model(self, ckpt_name=\"best_model.pth\"):\n path = \"/\".join(ckpt_name.split(\"/\")[:-1])\n chkpt = torch.load(ckpt_name)\n self.start_epoch = chkpt['epoch']\n self.best_metric = chkpt['best_metric']\n\n # fix the DataParallel caused problem with keys names\n if self.multi_gpu_flag:\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=False)\n self.net.load_state_dict(new_state_dict)\n else:\n try:\n self.net.load_state_dict(chkpt['state_dict'])\n except:\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=True)\n self.net.load_state_dict(new_state_dict)\n\n if self.load_optimizer_state:\n self.optimizer.load_state_dict(chkpt['optimizer'])\n logging.info(\"******** State loaded ********\")\n\n training_meta = pickle.load(open(f\"{path}/training_meta.pickle.dat\", \"rb\"))\n for k, v in training_meta.items():\n if k in self.__class__.__params:\n setattr(self, k, v)\n logging.info(\"******** Training params loaded ********\")","def load_checkpoint(ckpt_path):\n checkpoint = None\n if ckpt_path:\n logger.info(\"Loading checkpoint from %s\" % ckpt_path)\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\"cpu\"))\n\n if \"model\" in checkpoint.keys():\n # This preserves backward-compat for models using customed layernorm\n def fix_key(s):\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.b_2\", r\"\\1.layer_norm\\2.bias\", s\n )\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.a_2\", r\"\\1.layer_norm\\2.weight\", s\n )\n return s\n\n checkpoint[\"model\"] = {\n fix_key(k): v for k, v in checkpoint[\"model\"].items()\n }\n # Force add_ffnbias to True if bias found in model w_1 keys\n for key in checkpoint[\"model\"].keys():\n if \"w_1.bias\" in key:\n checkpoint[\"opt\"].add_ffnbias = True\n\n if not hasattr(checkpoint[\"opt\"], \"num_kv\"):\n checkpoint[\"opt\"].num_kv = 0\n if not hasattr(checkpoint[\"opt\"], \"add_ffnbias\"):\n checkpoint[\"opt\"].add_ffnbias = False\n if not hasattr(checkpoint[\"opt\"], \"parallel_residual\"):\n checkpoint[\"opt\"].parallel_residual = False\n if not hasattr(checkpoint[\"opt\"], \"shared_layer_norm\"):\n checkpoint[\"opt\"].shared_layer_norm = False\n if not hasattr(checkpoint[\"opt\"], \"use_ckpting\"):\n checkpoint[\"opt\"].use_ckpting = []\n if not hasattr(checkpoint[\"opt\"], \"relative_positions_buckets\"):\n checkpoint[\"opt\"].relative_positions_buckets = 0\n if not hasattr(checkpoint[\"opt\"], \"parallel_mode\"):\n checkpoint[\"opt\"].parallel_mode = \"data_parallel\"\n if not hasattr(checkpoint[\"opt\"], \"norm_eps\"):\n checkpoint[\"opt\"].norm_eps = 1e-6\n\n # fix v2 compatibility\n if \"generator\" in checkpoint.keys() and checkpoint[\"generator\"]:\n if \"0.weight\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"weight\"] = checkpoint[\"generator\"].pop(\n \"0.weight\"\n )\n if \"0.bias\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"bias\"] = checkpoint[\"generator\"].pop(\"0.bias\")\n # end of patch for backward compatibility\n\n return checkpoint","def load_checkpoint(tag, params, model):\r\n file_name = os.path.join(\"saved_models\", params.path, tag + \".pt\")\r\n logger.info(\"Load checkpoint from %s\" % file_name)\r\n if os.path.exists(file_name):\r\n checkpoint = torch.load(file_name, map_location='cpu')\r\n params.training_id = checkpoint['training_id']\r\n logger.info(checkpoint['training_id'])\r\n model.global_step = checkpoint['global_step']\r\n model.load_state_dict(checkpoint['model'])\r\n for i, optimizer in enumerate(model.optimizers):\r\n optimizer.load_state_dict(checkpoint['optimizers'][i])\r\n else:\r\n raise Exception(\"Checkpoint not found.\")","def load_checkpoint(filepath):\n checkpoint = torch.load(filepath)\n \n arch = checkpoint['arch']\n if arch == 'vgg':\n model = models.vgg16(pretrained=True)\n elif arch == 'densenet':\n model = models.densenet121(pretrained=True) \n \n model.class_to_idx = checkpoint['class_to_idx']\n model.classifier = checkpoint['classifier']\n model.classifier.load_sate_dict = checkpoint['classifier_state_dict']\n model.optimizer = checkpoint['optimizer_state_dict']\n model.input_size = checkpoint['input_size']\n model.output_size = checkpoint['output_size']\n \n return model","def load_model(model, checkpoint_path: str): \r\n checkpoint = torch.load(checkpoint_path)\r\n model.load_state_dict(checkpoint['model'])\r\n epoch = checkpoint['epoch']\r\n print('Loaded model from {}, epoch {}'.format(checkpoint_path, epoch))","def _init_model(self, checkpoint_path: str) -> None:\n # load weights\n logger.info(f\"Load weights from the checkpoint {checkpoint_path}\")\n checkpoint = torch.load(checkpoint_path, map_location=torch.device(\"cpu\"))\n\n state_dict = checkpoint[\"state_dict\"]\n self.orig_acc = checkpoint[\"test_acc\"]\n\n is_pruned = (\n next((name for name in state_dict if \"mask\" in name), None) is not None\n )\n\n if is_pruned:\n logger.info(\"Dummy prunning to load pruned weights\")\n model_utils.dummy_pruning(self.params_all)\n\n model_utils.initialize_params(self.model, state_dict)\n logger.info(\"Initialized weights\")\n\n # check the trained model is pruned\n\n if is_pruned:\n logger.info(\n \"Get masks and remove prunning reparameterization for prepare_qat\"\n )\n self.mask = model_utils.get_masks(self.model)\n model_utils.remove_pruning_reparameterization(self.params_all)","def load_model(path):\n if os.path.isfile(path):\n print(\"=> loading checkpoint '{}'\".format(path))\n checkpoint = torch.load(path)\n\n # # size of the top layer\n # N = checkpoint['state_dict']['top_layer.bias'].size()\n #\n # # build skeleton of the model\n # sob = 'sobel.0.weight' in checkpoint['state_dict'].keys()\n # model = models.__dict__[checkpoint['arch']](sobel=sob, out=int(N[0]))\n #\n # # deal with a dataparallel table\n # def rename_key(key):\n # if not 'module' in key:\n # return key\n # return ''.join(key.split('.module'))\n #\n # checkpoint['state_dict'] = {rename_key(key): val\n # for key, val\n # in checkpoint['state_dict'].items()}\n #\n # # load weights\n # model.load_state_dict(checkpoint['state_dict'])\n # print(\"Loaded\")\n # else:\n # model = None\n # print(\"=> no checkpoint found at '{}'\".format(path))\n\n # net = models.__dict__['ResNet18'](low_dim=128)\n # net = models.__dict__['resnet18'](low_dim=128)\n\n net = models.__dict__['alexnet'](out=128)\n # net = models.__dict__['Alexnet_C'](out=args.low_dim)\n\n net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))\n net.load_state_dict(checkpoint['net'])\n\n return net","def train(self, config: ConfigurationNode = None):\n if config is None:\n config = self.config\n # Create writable timestamp for easier record keeping\n timestamp = datetime.now().isoformat(sep=\"T\", timespec=\"auto\")\n name_timestamp = timestamp.replace(\":\", \"_\")\n\n # Start the mlflow run:\n mlflow.start_run(run_name=name_timestamp)\n\n # Check valid output path, set path from the path_cfg_override modules respectively\n assert config.OUTPUT_PATH != ''\n path_output = config.OUTPUT_PATH # output folder\n path_train = config.DATASET.TRAIN_DATA_PATH # training data folder\n path_val = config.DATASET.VAL_DATA_PATH # validation data folder\n\n # Make output dir and its parents if not exist.\n if not os.path.exists(path_output):\n os.makedirs(path_output)\n\n # Make result folders if they do not exist.\n self.results_dir = (Path(path_output) / name_timestamp)\n if not os.path.exists(self.results_dir):\n os.makedirs(self.results_dir)\n\n # Make backup folders if they do not exist.\n self.backup_dir = os.path.join(self.results_dir, 'model_backups')\n if not os.path.exists(self.backup_dir):\n os.makedirs(self.backup_dir)\n\n writer_tensorboard = SummaryWriter(log_dir=Path(self.results_dir / \"logs_tensorflow\"))\n\n # Now that CFG has been properly merged with new data along the way, time to dump a version of it into a string for trackability purposes.\n config.dump(stream=open(os.path.join(self.results_dir, f'config{name_timestamp}.yaml'), 'w'))\n\n # file path to store the state of the model.\n state_fpath = os.path.join(self.results_dir, f'model{name_timestamp}.pt')\n\n # ????\n perf_path = os.path.join(self.results_dir, f'trace{name_timestamp}.p')\n perf_trace = []\n\n # Load data, create the data loader objects from them.\n data_train = pickle.load(open(path_train, 'rb'))\n data_val = pickle.load(open(path_val, 'rb'))\n self.loader_train = build_data_loader(data_train, config.DATASET, True)\n self.loader_val = build_data_loader(data_val, config.DATASET, False)\n\n # Build the model using configue dict node\n self.model = build_model(config.MODEL)\n\n # Enable parallel multi GPU mode if the config specify it.\n if config.MODEL.PARALLEL:\n print(\"Utilized parallel processing\")\n self.model = torch.nn.DataParallel(self.model)\n\n current_epoch = 0\n\n # For resuming training (i.e. load checkpoint)\n if config.RESUME_PATH != \"\":\n checkpoint = torch.load(config.RESUME_PATH, map_location='cpu')\n current_epoch = checkpoint['epoch']\n self.model.load_state_dict(checkpoint[\"model_state\"])\n _ = self.model.cuda()\n\n # SOLVER EVALUATOR\n cfg_solver = config.MODEL.SOLVER\n\n # Build optimizer (between train/validation, using the solver portion of the configuration.\n optimizer = build_optimizer(self.model, cfg_solver)\n\n # Build evaluator (between train/validation, using the solver portion of the configuration.\n evaluator = build_evaluator(cfg_solver)\n\n evaluator.float().cuda()\n total_epochs = cfg_solver.TOTAL_EPOCHS\n\n\n # Main training epoch loop starts here.\n for epoch in range(current_epoch, total_epochs):\n\n # Train a single epoch\n self.train_epoch(epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard)\n\n mlflow.end_run()","def load_model_trainer_states_from_checkpoint(self, checkpoint_path, model=None):\n import os\n\n if model is None:\n try:\n import cloudpickle\n except ImportError:\n raise ImportError(\"cloudpickle is required to load model class\")\n logger.info(\"Loading model class\")\n model = cloudpickle.load(open(os.path.join(checkpoint_path, \"model_class.pkl\"), \"rb\"))\n\n self.model = HFWrapper(model)\n logger.info(\"Loading weights of previously trained model\")\n # Restoring model weights\n self.model.load_state_dict(\n # torch.load(os.path.join(training_args.output_dir, \"pytorch_model.bin\"))\n torch.load(os.path.join(checkpoint_path, \"pytorch_model.bin\"))\n )\n # Restoring random state\n rng_file = os.path.join(checkpoint_path, \"rng_state.pth\")\n checkpoint_rng_state = torch.load(rng_file)\n random.setstate(checkpoint_rng_state[\"python\"])\n np.random.set_state(checkpoint_rng_state[\"numpy\"])\n torch.random.set_rng_state(checkpoint_rng_state[\"cpu\"])\n torch.cuda.random.set_rng_state_all(checkpoint_rng_state[\"cuda\"])\n # Restoring AMP scaler\n if self.use_amp:\n self.scaler.load_state_dict(torch.load(os.path.join(checkpoint_path, \"scaler.pt\")))","def init_model(config: Union[str, Path, Config],\n checkpoint: Optional[str] = None,\n device: str = 'cuda:0',\n cfg_options: Optional[dict] = None):\n if isinstance(config, (str, Path)):\n config = Config.fromfile(config)\n elif not isinstance(config, Config):\n raise TypeError('config must be a filename or Config object, '\n 'but got {}'.format(type(config)))\n if cfg_options is not None:\n config.merge_from_dict(cfg_options)\n elif 'init_cfg' in config.model.backbone:\n config.model.backbone.init_cfg = None\n config.model.pretrained = None\n config.model.train_cfg = None\n init_default_scope(config.get('default_scope', 'mmseg'))\n\n model = MODELS.build(config.model)\n if checkpoint is not None:\n checkpoint = load_checkpoint(model, checkpoint, map_location='cpu')\n dataset_meta = checkpoint['meta'].get('dataset_meta', None)\n # save the dataset_meta in the model for convenience\n if 'dataset_meta' in checkpoint.get('meta', {}):\n # mmseg 1.x\n model.dataset_meta = dataset_meta\n elif 'CLASSES' in checkpoint.get('meta', {}):\n # < mmseg 1.x\n classes = checkpoint['meta']['CLASSES']\n palette = checkpoint['meta']['PALETTE']\n model.dataset_meta = {'classes': classes, 'palette': palette}\n else:\n warnings.simplefilter('once')\n warnings.warn(\n 'dataset_meta or class names are not saved in the '\n 'checkpoint\\'s meta data, classes and palette will be'\n 'set according to num_classes ')\n num_classes = model.decode_head.num_classes\n dataset_name = None\n for name in dataset_aliases.keys():\n if len(get_classes(name)) == num_classes:\n dataset_name = name\n break\n if dataset_name is None:\n warnings.warn(\n 'No suitable dataset found, use Cityscapes by default')\n dataset_name = 'cityscapes'\n model.dataset_meta = {\n 'classes': get_classes(dataset_name),\n 'palette': get_palette(dataset_name)\n }\n model.cfg = config # save the config in the model for convenience\n model.to(device)\n model.eval()\n return model","def restore_checkpoint(model, checkpoint_dir, cuda=False, force=False, pretrain=False):\n try:\n cp_files = [\n file_\n for file_ in os.listdir(checkpoint_dir)\n if file_.startswith(\"epoch=\") and file_.endswith(\".checkpoint.pth.tar\")\n ]\n except FileNotFoundError:\n cp_files = None\n os.makedirs(checkpoint_dir)\n if not cp_files:\n print(\"No saved model parameters found\")\n if force:\n raise Exception(\"Checkpoint not found\")\n else:\n return model, 0, []\n\n # Find latest epoch\n for i in itertools.count(1):\n if \"epoch={}.checkpoint.pth.tar\".format(i) in cp_files:\n epoch = i\n else:\n break\n\n if not force:\n print(\n \"Which epoch to load from? Choose in range [0, {}].\".format(epoch),\n \"Enter 0 to train from scratch.\",\n )\n print(\">> \", end=\"\")\n inp_epoch = int(input())\n if inp_epoch not in range(epoch + 1):\n raise Exception(\"Invalid epoch number\")\n if inp_epoch == 0:\n print(\"Checkpoint not loaded\")\n clear_checkpoint(checkpoint_dir)\n return model, 0, []\n else:\n print(\"Which epoch to load from? Choose in range [1, {}].\".format(epoch))\n inp_epoch = int(input())\n if inp_epoch not in range(1, epoch + 1):\n raise Exception(\"Invalid epoch number\")\n\n filename = os.path.join(\n checkpoint_dir, \"epoch={}.checkpoint.pth.tar\".format(inp_epoch)\n )\n\n print(\"Loading from checkpoint {}?\".format(filename))\n\n if cuda:\n checkpoint = torch.load(filename)\n else:\n # Load GPU model on CPU\n checkpoint = torch.load(filename, map_location=lambda storage, loc: storage)\n\n try:\n start_epoch = checkpoint[\"epoch\"]\n stats = checkpoint[\"stats\"]\n if pretrain:\n model.load_state_dict(checkpoint[\"state_dict\"], strict=False)\n else:\n model.load_state_dict(checkpoint[\"state_dict\"])\n print(\n \"=> Successfully restored checkpoint (trained for {} epochs)\".format(\n checkpoint[\"epoch\"]\n )\n )\n except:\n print(\"=> Checkpoint not successfully restored\")\n raise\n\n return model, inp_epoch, stats","def train_model(config: dict, load_weights=None, resume_epoch=None):\n # Set GPU memory optimization\n try:\n physical_devices = tf.config.list_physical_devices(\"GPU\")\n for index in range(len(physical_devices)):\n try:\n tf.config.experimental.set_memory_growth(physical_devices[index], True)\n\n except Exception as err:\n print(\"[WARN]: Failed to set memory growth for {0}\".format(physical_devices[index]))\n print(\"[WARN]: Error\", err, \" .Skipping memory optimization\")\n\n except Exception as err:\n print(\"[WARN]: memory optimization failed. Error:\", err, \" . Skipping!\")\n\n # Set up random states\n np.random.seed(100)\n random.seed(100)\n tf.random.set_seed(100)\n\n # Get the required configurations\n no_of_epochs = config[\"no_of_epochs\"]\n steps_per_epoch = config[\"steps_per_epoch\"] if config[\"steps_per_epoch\"] > 0 else None\n\n train_batch_size = config[\"train_batch_size\"]\n val_batch_size = config[\"val_batch_size\"]\n test_batch_size = config[\"test_batch_size\"]\n\n model_name = config[\"model_name\"]\n\n # Create the dataset\n dataset_path = config[\"dataset_path\"]\n dataset_family = config[\"dataset_family\"]\n\n # get width and height\n image_width = config[\"image_width\"]\n image_height = config[\"image_height\"]\n initial_width = config[\"initial_width\"]\n initial_height = config[\"initial_height\"]\n\n model_name = model_name + \"_\" + dataset_family\n\n print(\"[INFO]: Using Configuration: \\n\", config)\n\n # Set up environments\n folders = [\n \"./outputs/model_save/{0}/checkpoints/\".format(model_name),\n \"./outputs/output_logs/{0}/csv_log/\".format(model_name),\n \"./outputs/model_save/{0}/best_model/\".format(model_name),\n \"./outputs/model_save/{0}/saved_model/\".format(model_name),\n \"./outputs/output_logs/{0}/graphs/\".format(model_name)\n ]\n print(\"[INFO]: Setting up folders: \")\n os_utilities.make_directories(paths=folders)\n\n # Load the dataset\n print(\"[INFO]: Loading dataset\")\n if dataset_family == \"CVC-ClinicDB\":\n X, y = du.get_cvc_clinic_datapath(dataset_path)\n elif dataset_family == \"Kvasir-Seg\":\n X, y = du.get_kvasir_seg_datapath(dataset_path)\n else:\n print(\"[ERROR]: {0} dataset family is unrecognized or not supported!\".format(dataset_family))\n raise NotImplementedError\n\n X_train, X_sided, y_train, y_sided = train_test_split(X, y, random_state=100, test_size=0.2)\n X_val, X_test, y_val, y_test = train_test_split(X_sided, y_sided, random_state=100, test_size=0.5)\n\n print(\"[INFO]: Training set size: \", len(X_train))\n print(\"[INFO]: Validation set size: \", len(X_val))\n print(\"[INFO]: Testing set size: \", len(X_test))\n\n print(\"[INFO]: Loading Training set\")\n train_datagen = du.DataGenerator(X_train,\n y_train,\n image_size=(image_width, image_height),\n model_name=config[\"model_name\"],\n batch_size=train_batch_size,\n dataset_family=dataset_family,\n initial_size=(initial_width, initial_height),\n aug_config_path=\"./augmentation_config.yaml\",\n shuffle=True)\n\n print(\"[INFO]: Loading Validation set\")\n val_datagen = du.DataGenerator(X_val,\n y_val,\n image_size=(image_width, image_height),\n model_name=config[\"model_name\"],\n batch_size=val_batch_size,\n dataset_family=dataset_family,\n initial_size=None,\n aug_config_path=None,\n shuffle=False)\n\n print(\"[INFO]: Setting tf.data pipeline\")\n train_steps = len(train_datagen) if steps_per_epoch is None else int(steps_per_epoch)\n val_steps = len(val_datagen)\n\n train_dataset = train_datagen.get_tf_data()\n val_dataset = val_datagen.get_tf_data()\n\n # Get the model, loss and metrics\n print(\"[INFO]: Building the model - {0}\".format(model_name))\n model = models.ModelSelector(config)\n\n # Load the weights if available\n if load_weights is not None:\n print(\"[INFO]: Load the weights from {0}\".format(load_weights))\n model.load_weights(load_weights)\n\n # Setup Callbacks\n print(\"[INFO]: Setting up training Callbacks and Optimizers. Its almost done\")\n resume_epoch = 0 if resume_epoch is None else resume_epoch\n overwrite = True if resume_epoch == 0 else False\n\n train_csv_logger = callbacks.CSVLogging(\"./outputs/output_logs/{0}/csv_log/train_log.csv\".format(model_name),\n overwrite=overwrite)\n valid_csv_logger = callbacks.CSVLogging(\"./outputs/output_logs/{0}/csv_log/valid_log.csv\".format(model_name),\n overwrite=overwrite)\n lr_reducer = callbacks.ReduceLROnPlateau(learning_rate=float(config[\"learning_rate\"]),\n patience=4,\n decay_rate=1E-1,\n delta=0.0001,\n min_lr=1E-7,\n mode=\"min\")\n\n model_save_path = \"./outputs/model_save/{0}/\".format(model_name)\n\n # Setup Optimizer\n optimizer = tf.keras.optimizers.Adam(learning_rate=float(config[\"learning_rate\"]))\n\n # Check for monitor\n monitor_variable = 100.0 # Initialize a start max\n\n print(\"[INFO]: Setting up metrics\")\n loss_avg = tf.keras.metrics.Mean(name=\"loss\")\n f1_score_metric = tf.keras.metrics.Mean(name=\"f1_score\")\n iou_coe_metric = tf.keras.metrics.Mean(name=\"iou_coe\")\n dice_coe_metric = tf.keras.metrics.Mean(name=\"dice_coe\")\n\n # Set up a custom train loop\n print(\"[INFO]: Beginning training loops\")\n # Iterate epoch wise\n for epoch in range(resume_epoch, no_of_epochs):\n\n print(\"Training {0}/{1}\".format(epoch + 1, no_of_epochs))\n\n try:\n # Training-loop == using batches\n train_loss, train_f1_score, train_iou, train_dice = train(config[\"model_name\"],\n model,\n train_dataset,\n train_steps,\n metrics_tracker=(loss_avg,\n f1_score_metric,\n iou_coe_metric,\n dice_coe_metric),\n optimizer=optimizer,\n epoch=epoch + 1,\n total_epochs=no_of_epochs)\n\n train_tracker = {\n \"train_loss\": [train_loss],\n \"train_f1_score\": [train_f1_score],\n \"train_iou_coe\": [train_iou],\n \"train_dice_coe\": [train_dice]\n }\n\n # Validation loop == using batches\n val_loss, val_f1_score, val_iou, val_dice = train(config[\"model_name\"],\n model,\n val_dataset,\n val_steps,\n metrics_tracker=(loss_avg,\n f1_score_metric,\n iou_coe_metric,\n dice_coe_metric),\n optimizer=None,\n epoch=1,\n total_epochs=1)\n val_tracker = {\n \"val_loss\": [val_loss],\n \"val_f1_score\": [val_f1_score],\n \"val_iou_coe\": [val_iou],\n \"val_dice_coe\": [val_dice]\n }\n\n model.save_weights(model_save_path + \"checkpoints/{0}_ckpt.h5\".format(model_name))\n print(\"[INFO]: Epoch {0}/{1} - \\nTrain evaluation: {2}, \\nValidation evaluation: {3}\".\n format(epoch + 1, no_of_epochs, train_tracker, val_tracker))\n train_csv_logger.log(train_tracker)\n valid_csv_logger.log(val_tracker)\n\n # Save the best model\n if monitor_variable > val_loss:\n monitor_variable = val_loss\n model.save_weights(model_save_path + \"best_model/best_{0}.h5\".format(model_name))\n\n # LR Reduce\n lr_reducer.check_lr(monitor_variable=val_loss, optimizer=optimizer)\n\n except KeyboardInterrupt:\n print(\"[INFO]: Interrupted Training. Trying to save model\")\n model.save_weights(model_save_path + \"{0}_{1}_interrupted.h5\".format(model_name, epoch + 1))\n print(\"[INFO]: Attempting to run test on the best model so far!\")\n break\n\n except Exception as err:\n print(\"[ERROR]: Unexpected Critical Error: \", err)\n print(\"[ERROR]: Trying to save the weights\")\n model.save_weights(model_save_path + \"{0}_{1}_critical.h5\".format(model_name, epoch + 1))\n traceback.print_exc()\n sys.exit(2)\n\n print(\"[INFO]: Training completed. Saving model\")\n model.save_weights(model_save_path + \"saved_model/{0}.h5\".format(model_name))\n\n print(\"[INFO]: Testing model\")\n print(\"[INFO]: Loading Best saved model:\")\n model.load_weights(model_save_path + \"best_model/best_{0}.h5\".format(model_name))\n\n print(\"[INFO]: Loading the test set\")\n test_datagen = du.DataGenerator(X_test,\n y_test,\n image_size=(image_width, image_height),\n model_name=config[\"model_name\"],\n batch_size=test_batch_size,\n dataset_family=dataset_family,\n initial_size=None,\n aug_config_path=None,\n shuffle=False)\n\n print(\"[INFO]: Loading TF data\")\n test_dataset = test_datagen.get_tf_data()\n test_steps = len(test_datagen)\n\n print(\"[INFO]: Testing Initiated\")\n test_loss, test_f1_score, test_iou, test_dice = train(config[\"model_name\"],\n model,\n test_dataset,\n test_steps,\n metrics_tracker=(loss_avg,\n f1_score_metric,\n iou_coe_metric,\n dice_coe_metric),\n optimizer=None,\n epoch=1,\n total_epochs=1)\n test_tracker = {\n \"test_loss\": [test_loss],\n \"test_f1_score\": [test_f1_score],\n \"test_iou_coe\": [test_iou],\n \"test_dice_coe\": [test_dice]\n }\n print(\"[INFO]: Test Results: \\n\", test_tracker)\n with open(\"./outputs/output_logs/{0}/test_results.txt\".format(model_name), mode=\"w\") as f:\n f.write(\"Dumped Test Results for the model {0}\\n\".format(model_name))\n for k, v in test_tracker.items():\n f.write(\"{0} => {1}\\n\".format(k, v))\n\n print(\"[INFO]: Closing operations\")","def load(cls, path):\n print(f'load checkpoint from {path}')\n if torch.cuda.is_available():\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\n else:\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\n \n # model.flatten_parameters() # make RNN parameters contiguous\n optimizer = resume_checkpoint['optimizer']\n return Checkpoint(\n model=model, \n optimizer=optimizer,\n epoch=resume_checkpoint['epoch'],\n path=path\n )","def eval_model(config):\n print 'Model directory: %s' % config.model_output\n print 'Running model: %s' % config.model_type\n if config.model_type == 'fully_connected_mlp':\n from models.fully_connected_mlp import model_struct\n elif config.model_type == 'fully_connected_mlp_2l':\n from models.fully_connected_mlp_2l import model_struct\n elif config.model_type == 'fully_connected_conv':\n from models.fully_connected_conv import model_struct\n elif config.model_type == 'vgg_feature_model':\n from models.vgg_feature_model import model_struct\n else:\n raise Exception\n\n # Prepare model training\n dt_stamp = re.split(\n '\\.', str(datetime.now()))[0].\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\n dt_dataset = config.model_type + '_' + dt_stamp + '/'\n config.train_checkpoint = os.path.join(\n config.model_output, dt_dataset) # timestamp this run\n config.summary_dir = os.path.join(\n config.train_summaries, config.model_output, dt_dataset)\n dir_list = [config.train_checkpoint, config.summary_dir]\n [make_dir(d) for d in dir_list]\n\n # Prepare model inputs\n train_data = os.path.join(config.tfrecord_dir, 'train.tfrecords')\n validation_data = os.path.join(config.tfrecord_dir, 'val.tfrecords')\n feat_mean = 0 # np.mean(np.load(config.mean_file)['feat_list'])\n\n # Prepare data on CPU\n with tf.device('/cpu:0'):\n train_images, train_labels = inputs(\n tfrecord_file=train_data,\n batch_size=config.train_batch,\n num_feats=config.n_features,\n sample=config.sample['train'],\n max_pixels_per_image=config.max_pixels_per_image,\n im_size=config.resize,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n num_epochs=config.epochs,\n feat_mean_value=feat_mean)\n val_images, val_labels = inputs(\n tfrecord_file=validation_data,\n batch_size=1,\n num_feats=config.n_features,\n sample=config.sample['val'],\n max_pixels_per_image=config.max_pixels_per_image,\n im_size=config.resize,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n num_epochs=config.epochs,\n feat_mean_value=feat_mean)\n tf.summary.image('validation images', tf.cast(val_labels, tf.float32))\n\n # Prepare model on GPU\n with tf.device('/gpu:0'):\n with tf.variable_scope('cnn') as scope:\n\n model = model_struct()\n train_mode = tf.get_variable(name='training', initializer=True)\n model.build(\n features=train_images,\n output_categories=len(config.labels.keys()),\n train_mode=train_mode, batchnorm=config.batch_norm)\n\n # Prepare the cost function\n cost = softmax_cost(\n model.res_logits, train_labels, ratio=config.ratio,\n label_reshape=[\n config.batch_size * config.max_pixels_per_image])\n train_op = tf.train.AdamOptimizer(config.lr).minimize(cost)\n\n tf.summary.scalar(\"cost\", cost)\n\n train_score = correlation(\n model.prob, train_labels) # training accuracy\n tf.summary.scalar(\"training correlation\", train_score)\n\n # Setup validation op\n if validation_data is not False:\n scope.reuse_variables()\n # Validation graph is the same as training except no batchnorm\n val_model = model_struct()\n val_model.build(\n features=val_images,\n output_categories=len(config.labels.keys()))\n\n # Calculate validation accuracy\n val_pred = tf.cast(\n tf.reshape(\n tf.argmax(\n val_model.prob, axis=1),\n [1, config.resize[0], config.resize[1], 1]),\n tf.float32)\n tf.summary.image('validation prediction', val_pred)\n val_score = correlation(\n val_model.prob, tf.reshape(\n val_labels, [np.prod(config.resize), 1]))\n tf.summary.scalar(\"validation correlation\", val_score)\n\n # Set up summaries and saver\n saver = tf.train.Saver(\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\n summary_op = tf.summary.merge_all()\n\n # Initialize the graph\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\n\n # Need to initialize both of these if supplying num_epochs to inputs\n sess.run(tf.group(tf.global_variables_initializer(),\n tf.local_variables_initializer()))\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\n\n # Set up exemplar threading\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n\n # Start training loop\n np.save(config.train_checkpoint, config)\n step, val_max, losses = 0, 0, []\n train_acc = 0\n try:\n while not coord.should_stop():\n start_time = time.time()\n _, loss_value, train_acc = sess.run([train_op, cost, train_score])\n losses.append(loss_value)\n duration = time.time() - start_time\n assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\n\n if step % 100 == 0 and step % 10 == 0:\n if validation_data is not False:\n _, val_acc, val_frame = sess.run(\n [train_op, val_score, val_pred])\n\n np.save(\n os.path.join(\n config.model_output, '%s_val_image' % step),\n val_frame)\n else:\n val_acc = -1 # Store every checkpoint\n\n # Summaries\n summary_str = sess.run(summary_op)\n summary_writer.add_summary(summary_str, step)\n\n # Training status and validation accuracy\n format_str = (\n '%s: step %d, loss = %.2f (%.1f examples/sec; '\n '%.3f sec/batch) | Training r = %s | '\n 'Validation r = %s | logdir = %s')\n print (format_str % (\n datetime.now(), step, loss_value,\n config.train_batch / duration, float(duration),\n train_acc, val_acc, config.summary_dir))\n\n # Save the model checkpoint if it's the best yet\n if val_acc > val_max:\n saver.save(\n sess, os.path.join(\n config.train_checkpoint,\n 'model_' + str(step) + '.ckpt'), global_step=step)\n\n # Store the new max validation accuracy\n val_max = val_acc\n\n else:\n # Training status\n format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; '\n '%.3f sec/batch) | Training F = %s')\n print (format_str % (datetime.now(), step, loss_value,\n config.train_batch / duration,\n float(duration), train_acc))\n # End iteration\n step += 1\n\n except tf.errors.OutOfRangeError:\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\n finally:\n coord.request_stop()\n\n dt_stamp = get_dt() # date-time stamp\n np.save(\n os.path.join(\n config.tfrecord_dir, '%straining_loss' % dt_stamp), losses)\n coord.join(threads)\n sess.close()","def createModel(config_path, checkpoint_path, graph_path):\n\n global build_graph, prev_classes\n\n trt_graph = None\n input_names = None\n \n if build_graph:\n frozen_graph, input_names, output_names = build_detection_graph(\n config=config_path,\n checkpoint=checkpoint_path\n )\n \n trt_graph = trt.create_inference_graph(\n input_graph_def=frozen_graph,\n outputs=output_names,\n max_batch_size=1,\n max_workspace_size_bytes=1 << 25,\n precision_mode='FP16',\n minimum_segment_size=50\n )\n\n with open(graph_path, 'wb') as f:\n f.write(trt_graph.SerializeToString())\n\n with open('config.txt', 'r+') as json_file: \n data = json.load(json_file)\n data['model'] = []\n data['model'] = [{'input_names': input_names}]\n json_file.seek(0)\n json_file.truncate()\n json.dump(data, json_file)\n\n else:\n with open(graph_path, 'rb') as f:\n trt_graph = tf.GraphDef()\n trt_graph.ParseFromString(f.read())\n with open('config.txt') as json_file: \n data = json.load(json_file)\n input_names = data['model'][0]['input_names']\n\n return Model(trt_graph, input_names)","def _restore_checkpoint(self, checkpoint_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(checkpoint_path))\n checkpoint = torch.load(checkpoint_path)\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\n \n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\n print('Parameters are inconsistant, adapting model parameters ...')\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\n del pretrained_dict['1']\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\n self.model.load_state_dict(model_dict)\n else:\n print('Parameters are consistant, load state dict directly ...')\n self.model.load_state_dict(checkpoint['state_dict'])\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\n # if self.with_cuda:\n # for state in self.optimizer.state.values():\n # for k, v in state.items():\n # if isinstance(v, torch.Tensor):\n # state[k] = v.cuda(self.device)","def load_model(self, checkpoint_path):\n model = self.model_definition()\n model.load_weights(checkpoint_path)\n return model","def load_model(self, fname: str) -> None:\n checkpoint_data = torch.load(fname)\n\n # Load the models\n # P-Net\n model_import_path = checkpoint_data['p_net']['model_import_path']\n imp = importlib.import_module(model_import_path)\n mod = getattr(imp, checkpoint_data['p_net']['model_name'])\n self.p_net = mod()\n self.p_net.set_params(checkpoint_data['p_net'])\n # Q-Net\n model_import_path = checkpoint_data['q_net']['model_import_path']\n imp = importlib.import_module(model_import_path)\n mod = getattr(imp, checkpoint_data['q_net']['model_name'])\n self.q_net = mod()\n self.q_net.set_params(checkpoint_data['q_net'])","def load_checkpoint(self, path: str = '', train: bool = True) -> int:\n\n if not path:\n dir_ = os.path.dirname(os.path.realpath('__file__'))\n path = os.path.join(dir_, 'model.pt')\n\n try:\n ckpt = torch.load(path)\n except FileNotFoundError:\n return 0\n else:\n print('Loaded model at epoch: ', end='')\n\n self.load_state_dict(ckpt['model_state_dict'])\n self.actor_optimizer.load_state_dict(ckpt['ac_optim_dict'])\n self.critic_optimizer.load_state_dict(ckpt['critic_optim_dict'])\n epoch = ckpt['epoch']\n\n print(epoch)\n\n if not train:\n self.eval()\n else:\n self.train()\n\n return epoch","def train(model_name, batch_size, steps_per_epoch, epochs, validation_steps, \n model_file=None, save_path=None):\n \n print(\"- Loading configuration...\")\n if model_name in models_default_params:\n default_params = models_default_params[model_name]\n else:\n print(\"Error: the model '{}' has not been implemented\".format(model_name))\n return\n custom_objects = default_params['custom_objects']\n patch_size = default_params['patch_size']\n if save_path is None:\n save_path = default_params['default_path']\n if os.path.isfile(save_path):\n print(\"Warning: {} is an existing file and will be overwritten.\".format(save_path))\n print(\"- Configuration loaded.\")\n \n print(\"- Loading datasets...\")\n train_gen = preprocess.load_dataset(batch_size, x_directory = \"datasets/Potsdam/Training/RGB/\",\n y_directory = \"datasets/Potsdam/Training/Labels/\",\n patch_size = patch_size)\n val_gen = preprocess.load_dataset(batch_size, x_directory = \"datasets/Potsdam/Validation/RGB/\",\n y_directory = \"datasets/Potsdam/Validation/Labels/\",\n patch_size = patch_size)\n print(\"- Data loaded.\")\n \n print(\"- Initialising model...\")\n if(model_file is not None): # Further train existing model\n model = keras.models.load_model(model_file, custom_objects=custom_objects)\n else: # Create new model\n if model_name == 'fcn':\n model = fcn.make_fcn_resnet((patch_size, patch_size, channels), nb_labels, \n use_pretraining=False, freeze_base=False)\n elif model_name == 'pspnet':\n model = pspnet.build_pspnet(nb_classes=nb_labels, resnet_layers=50,\n input_shape=patch_size)\n elif model_name == 'mobilenetv2':\n model = mobilenetv2.MobileNetv2((patch_size, patch_size, channels), nb_labels) \n\n model.compile(\n optimizer = optimizers.Adam(lr = 0.00001),\n loss = losses.categorical_crossentropy,\n metrics = [metrics.categorical_accuracy]) \n model.summary() \n print(\"- Model initialised.\")\n \n tensorboard = callbacks.TensorBoard(log_dir='./logs')\n csv_logger = callbacks.CSVLogger('logs/training.csv')\n checkpoint = callbacks.ModelCheckpoint(filepath=checkpoint_path,\n save_weights_only=True,\n save_best_only=True)\n \n print(\"- Starting training.\")\n model.fit_generator(\n generator=train_gen,\n steps_per_epoch=steps_per_epoch,\n epochs=epochs,\n validation_data=val_gen,\n validation_steps=validation_steps,\n # callbacks=[checkpoint, csv_logger]\n )\n print(\"- Training complete.\")\n \n model.save(save_path)\n print(\"- Model saved to {}\".format(save_path))","def load_checkpoint(self):\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\n try:\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\n ckpt = torch.load(self.params.resume_from)\n self.epoch = ckpt['epoch']\n try:\n self.train_loss = ckpt['train_loss']\n self.val_loss = ckpt['val_loss']\n except:\n self.train_loss = []\n self.val_loss = []\n self.network.load_state_dict(ckpt['state_dict'])\n self.opt.load_state_dict(ckpt['optimizer'])\n LOG('Checkpoint Loaded!')\n LOG('Current Epoch: %d' % self.epoch)\n self.ckpt_flag = True\n except:\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\n else:\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')","def initialize_model(session, model, train_dir, expect_exists):\n print \"Looking for model at %s...\" % train_dir\n ckpt = tf.train.get_checkpoint_state(train_dir)\n v2_path = ckpt.model_checkpoint_path + \".index\" if ckpt else \"\"\n if ckpt and (tf.gfile.Exists(ckpt.model_checkpoint_path) or tf.gfile.Exists(v2_path)):\n print \"Reading model parameters from %s\" % ckpt.model_checkpoint_path\n model.saver.restore(session, ckpt.model_checkpoint_path)\n else:\n if expect_exists:\n raise Exception(\"There is no saved checkpoint at %s\" % train_dir)\n else:\n print \"There is no saved checkpoint at %s. Creating model with fresh parameters.\" % train_dir\n session.run(tf.global_variables_initializer())\n print 'Num params: %d' % sum(v.get_shape().num_elements() for v in tf.trainable_variables())","def initialize_model(session, model, train_dir, expect_exists):\n print \"Looking for model at %s...\" % train_dir\n ckpt = tf.train.get_checkpoint_state(train_dir)\n v2_path = ckpt.model_checkpoint_path + \".index\" if ckpt else \"\"\n if ckpt and (tf.gfile.Exists(ckpt.model_checkpoint_path) or tf.gfile.Exists(v2_path)):\n print \"Reading model parameters from %s\" % ckpt.model_checkpoint_path\n model.saver.restore(session, ckpt.model_checkpoint_path)\n else:\n if expect_exists:\n raise Exception(\"There is no saved checkpoint at %s\" % train_dir)\n else:\n print \"There is no saved checkpoint at %s. Creating model with fresh parameters.\" % train_dir\n session.run(tf.global_variables_initializer())\n print 'Num params: %d' % sum(v.get_shape().num_elements() for v in tf.trainable_variables())","def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):\n\n config = kwargs.pop(\"config\", None)\n state_dict = kwargs.pop(\"state_dict\", None)\n cache_dir = kwargs.pop(\"cache_dir\", None)\n from_tf = kwargs.pop(\"from_tf\", False)\n from_hf = kwargs.pop(\"from_hf\", False)\n output_loading_info = kwargs.pop(\"output_loading_info\", False)\n default_gpu = kwargs.pop(\"default_gpu\", True)\n\n # Load config\n assert config is not None\n model_kwargs = kwargs\n\n # Load model\n if pretrained_model_name_or_path in cls.pretrained_model_archive_map:\n archive_file = cls.pretrained_model_archive_map[pretrained_model_name_or_path]\n elif os.path.isdir(pretrained_model_name_or_path):\n if from_tf:\n # Directly load from a TensorFlow checkpoint\n archive_file = os.path.join(pretrained_model_name_or_path, TF_WEIGHTS_NAME + \".index\")\n else:\n archive_file = os.path.join(pretrained_model_name_or_path, WEIGHTS_NAME)\n else:\n if from_tf:\n # Directly load from a TensorFlow checkpoint\n archive_file = pretrained_model_name_or_path + \".index\"\n else:\n archive_file = pretrained_model_name_or_path\n # redirect to the cache, if necessary\n try:\n resolved_archive_file = cached_path(archive_file, cache_dir=cache_dir)\n except EnvironmentError:\n if pretrained_model_name_or_path in cls.pretrained_model_archive_map:\n logger.error(\"Couldn't reach server at '{}' to download pretrained weights.\".format(archive_file))\n else:\n logger.error(\n \"Model name '{}' was not found in model name list ({}). \"\n \"We assumed '{}' was a path or url but couldn't find any file \"\n \"associated to this path or url.\".format(\n pretrained_model_name_or_path, \", \".join(cls.pretrained_model_archive_map.keys()), archive_file)\n )\n return None\n if default_gpu:\n if resolved_archive_file == archive_file:\n logger.info(\"loading weights file {}\".format(archive_file))\n else:\n logger.info(\"loading weights file {} from cache at {}\".format(archive_file, resolved_archive_file))\n\n # Instantiate model.\n model = cls(config, *model_args, **model_kwargs)\n\n if state_dict is None and not from_tf:\n state_dict = torch.load(resolved_archive_file, map_location=\"cpu\")\n if from_tf:\n # Directly load from a TensorFlow checkpoint\n return cls.load_tf_weights(model, config, resolved_archive_file[:-6]) # Remove the '.index'\n\n # Convert old format to new format if needed from a PyTorch state_dict\n old_keys = []\n new_keys = []\n for key in state_dict.keys():\n new_key = None\n if \"gamma\" in key:\n new_key = key.replace(\"gamma\", \"weight\")\n if \"beta\" in key:\n new_key = key.replace(\"beta\", \"bias\")\n if new_key:\n old_keys.append(key)\n new_keys.append(new_key)\n for old_key, new_key in zip(old_keys, new_keys):\n state_dict[new_key] = state_dict.pop(old_key)\n\n # Rename Bert parameters for our framework\n # NB: Assume 1 Bert layer is mapped to 1 layer only (cannot be used to init multiple layers)\n old_keys = []\n new_keys = []\n nums = []\n for key in state_dict.keys():\n new_key = None\n if \".layer.\" in key and from_hf:\n num = int(key.split(\".layer.\")[-1].split(\".\")[0])\n if \".attention.\" in key:\n new_key = key.replace(\".layer.%d.attention.\" % num,\n \".layer.%d.attention_\" % config.bert_layer2attn_sublayer.get(str(num), num))\n elif \".intermediate.\" in key:\n new_key = key.replace(\".layer.%d.intermediate.\" % num,\n \".layer.%d.intermediate.\" % config.bert_layer2ff_sublayer.get(str(num), num))\n elif \".output.\" in key:\n new_key = key.replace(\".layer.%d.output.\" % num,\n \".layer.%d.output.\" % config.bert_layer2ff_sublayer.get(str(num), num))\n if new_key:\n old_keys.append(key)\n new_keys.append(new_key)\n nums.append(num)\n for old_key, new_key, _ in sorted(zip(old_keys, new_keys, nums), key=lambda x: x[2], reverse=True):\n state_dict[new_key] = state_dict.pop(old_key)\n\n # Load from a PyTorch state_dict\n missing_keys = []\n unexpected_keys = []\n error_msgs = []\n # copy state_dict so _load_from_state_dict can modify it\n metadata = getattr(state_dict, \"_metadata\", None)\n state_dict = state_dict.copy()\n if metadata is not None:\n state_dict._metadata = metadata\n\n def load(module, prefix=\"\"):\n local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {})\n module._load_from_state_dict(\n state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs,\n )\n for name, child in module._modules.items():\n if child is not None:\n load(child, prefix + name + \".\")\n\n # Make sure we are able to load base models as well as derived models (with heads)\n start_prefix = \"\"\n model_to_load = model\n if not hasattr(model, cls.base_model_prefix) and any(\n s.startswith(cls.base_model_prefix) for s in state_dict.keys()\n ):\n start_prefix = cls.base_model_prefix + \".\"\n if hasattr(model, cls.base_model_prefix) and not any(\n s.startswith(cls.base_model_prefix) for s in state_dict.keys()\n ):\n model_to_load = getattr(model, cls.base_model_prefix)\n\n logger.info(start_prefix)\n load(model_to_load, prefix=start_prefix)\n if len(missing_keys) > 0 and default_gpu:\n logger.info(\n \"Weights of {} not initialized from pretrained model: {}\".format(model.__class__.__name__, missing_keys)\n )\n if len(unexpected_keys) > 0 and default_gpu:\n logger.info(\n \"Weights from pretrained model not used in {}: {}\".format(model.__class__.__name__, unexpected_keys)\n )\n if len(error_msgs) > 0 and default_gpu:\n raise RuntimeError(\n \"Error(s) in loading state_dict for {}:\\n\\t{}\".format(model.__class__.__name__, \"\\n\\t\".join(error_msgs))\n )\n\n if hasattr(model, \"tie_weights\"):\n model.tie_weights() # make sure word embedding weights are still tied\n\n # Set model in evaluation mode to desactivate DropOut modules by default\n model.eval()\n\n if output_loading_info:\n loading_info = {\n \"missing_keys\": missing_keys,\n \"unexpected_keys\": unexpected_keys,\n \"error_msgs\": error_msgs,\n }\n return model, loading_info\n\n return model","def _load_weights_to_model(self, model: nn.Module,\n checkpoint: Optional[dict],\n cfg: Optional[ConfigType]) -> None:\n if checkpoint is not None:\n _load_checkpoint_to_model(model, checkpoint)\n else:\n warnings.warn('Checkpoint is not loaded, and the inference '\n 'result is calculated by the randomly initialized '\n 'model!')","def prepare_model_optimizer_and_scheduler(self):\n\n ###################################################################\n # MODEL PREPARATION\n # -----------------\n # - step 1: Initialize a random model from config\n # - step 2: Load model weights from checkpoint if any\n # - step 3: Move model to device (GPU)\n ###################################################################\n\n # Initialize a random model according to a specific config:\n # NOTE: here we load from a physical path instead of using a keyword\n # as compute nodes may not allow downloading from online hubs\n if self.is_character_bert:\n model_config = CharacterBertConfig.from_pretrained(\n os.path.join(WORKDIR, 'data', 'character-bert'))\n model = CharacterBertForPreTraining(model_config)\n else:\n model_config = BertConfig.from_pretrained(\n os.path.join(WORKDIR, 'data', 'bert-base-uncased'))\n model = BertForPreTraining(model_config)\n if self.is_main_process:\n logging.info(\n \"Initialized %s using Config:\\n%s\",\n \"CharacterBERT\" if self.is_character_bert else \"BERT\",\n model_config\n )\n\n # Load checkpoint if any:\n if not self.resume_pretraining:\n # CASE: no checkpoint -> training from scratch\n self.global_step = 0\n if self.is_main_process:\n logging.info(\"Pre-training from scratch (good luck!)\")\n else:\n if self.init_checkpoint:\n # CASE: load checkpoint from direct path\n self.global_step = 0\n init_checkpoint = self.init_checkpoint\n if self.is_main_process:\n logging.info(\n \"Resuming pre-training from specific checkpoint `%s`\",\n init_checkpoint\n )\n else:\n # CASE: load checkpoint from resume_step\n if self.is_main_process:\n logging.info(\n \"Resuming pre-training from step `%s`. \"\n \"Looking inside `output_directory` for checkpoints...\",\n self.resume_step\n )\n\n if self.resume_step == -1:\n # CASE: resume_step == -1, load latest checkpoint\n model_names = [\n fname\n for fname in os.listdir(self.output_directory)\n if fname.endswith(\".pt\")]\n assert model_names, \"Could not find any checkpoints to resume from.\"\n self.resume_step = max([\n int(x.split('.pt')[0].split('_')[1].strip())\n for x in model_names]) # TODO: find a better way for this\n if self.is_main_process:\n logging.info(\n \"Resuming from latest checkpoint: ckpt_%s.pt\",\n self.resume_step\n )\n else:\n # CASE: resume_step == X, load checkpoint: `ckpt_X.pt`\n if self.is_main_process:\n logging.info(\n \"Resuming from checkpoint: ckpt_%s.pt\",\n self.resume_step\n )\n self.global_step = self.resume_step\n init_checkpoint = os.path.join(\n self.output_directory, f\"ckpt_{self.resume_step}.pt\")\n\n # Load the actual checkpoint file\n self.checkpoint = torch.load(\n init_checkpoint, map_location=\"cpu\"\n )\n\n # NOTE: Keeping these lines below as a reminder that re-training on\n # a different domain with CharacterBERT requires changing the\n # output layer with a topK tokens matrix from the new domain.\n\n # # Case where we would retrain a general_domain CharacterBERT\n # # on the medical domain. Don't use the general domain output layer:\n # if self.is_medical_domain and self.is_character_bert and (not self.phase2):\n # model.load_state_dict(\n # {\n # k: v for (k, v) in self.checkpoint['model'].items()\n # # Don't load output matrix from general domain model\n # if not k.startswith('cls.predictions') # ignoring the old output layer\n # },\n # strict=False)\n # if self.is_main_process:\n # logging.warning(\n # \"Loaded model weights from `%s`, \"\n # \"but ignored the `cls.predictions` module.\",\n # init_checkpoint)\n\n # # General case: load weights from checkpoint\n # else:\n # model.load_state_dict(self.checkpoint['model'], strict=True)\n # if self.is_main_process:\n # logging.info('Loaded model weights from `%s`',\n # init_checkpoint)\n\n # General case: load weights from checkpoint\n model.load_state_dict(self.checkpoint['model'], strict=True)\n if self.is_main_process:\n logging.info('Loaded model weights from `%s`', init_checkpoint)\n\n # Deduce previous steps from phase1 when in phase2\n if self.phase2 and not self.init_checkpoint:\n self.global_step -= self.phase1_end_step\n\n if self.is_main_process:\n logging.info(\"Training will start at global_step=%s\", self.global_step)\n\n # Move model to GPU:\n model.to(self.device)\n if self.is_main_process:\n logging.info(\"Model was moved to device: %s\", self.device)\n\n ###################################################################\n # OPTIMIZER / SCHEDULER PREPARATION\n # ---------------------------------\n # - step 1: Define the optimizer (FusedLAMB w/ some weight decay)\n # - step 2: Define the learning rate scheduler (PolyWarmUpScheduler)\n ###################################################################\n\n # Initialize an optimizer:\n no_decay = ['bias', 'gamma', 'beta', 'LayerNorm'] # no weight decay\n optimizer_grouped_parameters = [\n {\n 'params': [\n param for name, param in model.named_parameters()\n if not any((nd in name) for nd in no_decay)],\n 'weight_decay': 0.01\n },\n {\n 'params': [\n param for name, param in model.named_parameters()\n if any((nd in name) for nd in no_decay)],\n 'weight_decay': 0.0\n }\n ]\n optimizer = FusedLAMB(\n optimizer_grouped_parameters, lr=self.learning_rate)\n if self.is_main_process:\n logging.info(\"Using optimizer: %s\", optimizer)\n\n # Initialize a learning rate scheduler:\n self.lr_scheduler = PolyWarmUpScheduler(\n optimizer,\n warmup=self.warmup_proportion,\n total_steps=self.total_steps\n )\n if self.is_main_process:\n logging.info(\"Using scheduler: %s\", self.lr_scheduler)\n\n ###################################################################\n # OTHER PREPARATION STEPS\n # -----------------------\n # - step 1: Set up Mixed Precision training (fp16) if required\n # - step 2: Load optimizer stat from checkpoint if any\n # - step 2: Set up DataParallel\n ###################################################################\n\n # Set up fp16:\n if self.fp16:\n if self.is_main_process:\n logging.info(\"Setting up `Almost FP16` Mixed Precision...\")\n if self.loss_scale == 0:\n model, optimizer = amp.initialize(\n model, optimizer, opt_level=\"O2\", loss_scale=\"dynamic\")\n else:\n model, optimizer = amp.initialize(\n model, optimizer, opt_level=\"O2\", loss_scale=self.loss_scale)\n amp._amp_state.loss_scalers[0]._loss_scale = 2**20\n\n # Load optimizer state from checkpoint\n if self.resume_pretraining:\n if self.is_main_process:\n logging.info(\"Loading optimizer state from checkpoint...\")\n if self.phase2 or self.init_checkpoint:\n keys = list(self.checkpoint['optimizer']['state'].keys())\n # Override hyperparameters from previous self.checkpoint\n for key in keys:\n self.checkpoint['optimizer']['state'][key]['step'] = self.global_step\n for i, _ in enumerate(self.checkpoint['optimizer']['param_groups']):\n self.checkpoint['optimizer']['param_groups'][i]['step'] = self.global_step\n self.checkpoint['optimizer']['param_groups'][i]['t_total'] = self.total_steps\n self.checkpoint['optimizer']['param_groups'][i]['warmup'] = self.warmup_proportion\n self.checkpoint['optimizer']['param_groups'][i]['lr'] = self.learning_rate\n if self.is_main_process:\n logging.info(\"Overwrote the following parameters with new values:\")\n logging.info(\"* step: %s\", self.global_step)\n logging.info(\"* t_total: %s\", self.total_steps)\n logging.info(\"* warmup: %s\", self.warmup_proportion)\n logging.info(\"* lr: %s\", self.learning_rate)\n optimizer.load_state_dict(self.checkpoint['optimizer'])\n # Restore AMP master parameters\n if self.fp16:\n if self.is_main_process:\n logging.info(\"Restoring AMP master parameters (optimizer)...\")\n optimizer._lazy_init_maybe_master_weights()\n optimizer._amp_stash.lazy_init_called = True\n optimizer.load_state_dict(self.checkpoint['optimizer'])\n for param, saved_param in zip(amp.master_params(optimizer), self.checkpoint['master params']):\n param.data.copy_(saved_param.data)\n\n # Distribute model\n if self.training_is_distributed:\n if not self.allreduce_post_accumulation:\n model = DistributedDataParallel(\n model,\n message_size=250000000,\n gradient_predivide_factor=\\\n torch.distributed.get_world_size()\n )\n else:\n flat_dist_call(\n [param.data for param in model.parameters()],\n torch.distributed.broadcast,\n (0,)\n )\n elif self.n_gpu > 1:\n model = torch.nn.DataParallel(model)\n\n # Set the values of self.model and self.optimizer\n self.model = model\n self.optimizer = optimizer","def train_and_eval(config, babas_data):\n\n if config.resume_from_checkpoint is not None:\n try:\n if config.augment_background == 'background':\n bg = config.augment_background\n else:\n bg = None\n rfc = config.resume_from_checkpoint\n ic = config.include_validation\n print 'Loading saved config: %s' % config.saved_config\n config = np.load(config.saved_config).item()\n config.resume_from_checkpoint = rfc\n config.include_validation = ic\n if not hasattr(config, 'augment_background'):\n config.augment_background = 'constant'\n if not hasattr(config, 'background_folder'):\n config.background_folder = 'backgrounds'\n if bg is not None:\n print 'Overriding saved config to add kinect backgrounds to training.'\n config.augment_background = bg\n results_dir = rfc\n except:\n print 'Relying on default config file.'\n\n if babas_data: # Shitty naive training method\n config.tfrecord_dir = '/media/data_cifs/monkey_tracking/data_for_babas/tfrecords_from_babas'\n config.babas_tfrecord_dir = config.tfrecord_dir\n config.steps_before_validation = 20\n config.epochs = 2000\n config.convert_labels_to_pixel_space = False\n config.augment_background = 'constant'\n\n # Import your model\n print 'Model directory: %s' % config.model_output\n print 'Running model: %s' % config.model_type\n model_file = import_cnn(config.model_type)\n\n # Prepare model training\n dt_stamp = re.split(\n '\\.', str(datetime.now()))[0].\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\n dt_dataset = '%s_%s' % (config.model_type, dt_stamp)\n if config.selected_joints is not None:\n dt_dataset = '_%s' % (config.selected_joints) + dt_dataset\n config.train_checkpoint = os.path.join(\n config.model_output, dt_dataset) # timestamp this run\n config.summary_dir = os.path.join(\n config.train_summaries, dt_dataset)\n results_dir = os.path.join(config.npy_dir, dt_dataset)\n print 'Saving Dmurphy\\'s online updates to: %s' % results_dir\n dir_list = [config.train_checkpoint, config.summary_dir, results_dir]\n [tf_fun.make_dir(d) for d in dir_list]\n\n # Prepare model inputs\n train_data = os.path.join(config.tfrecord_dir, config.train_tfrecords)\n if config.babas_tfrecord_dir is not None:\n train_babas_tfrecord_dir = os.path.join(\n config.babas_tfrecord_dir,\n config.train_tfrecords)\n if config.include_validation or config.include_validation is None:\n val_babas_tfrecord_dir = os.path.join(\n config.babas_tfrecord_dir,\n config.val_tfrecords)\n else:\n train_babas_tfrecord_dir = None\n val_babas_tfrecord_dir = None\n\n if isinstance(config.include_validation, basestring):\n validation_data = config.include_validation\n elif config.include_validation == True:\n validation_data = os.path.join(\n config.tfrecord_dir,\n config.val_tfrecords)\n else:\n validation_data = None\n\n print 'Using training set: %s' % train_data\n print 'Using validation set: %s' % validation_data\n\n # Prepare data on CPU\n with tf.device('/cpu:0'):\n train_data_dict = inputs(\n tfrecord_file=train_data,\n batch_size=config.train_batch,\n im_size=config.resize,\n target_size=config.image_target_size,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n label_shape=config.num_classes,\n num_epochs=config.epochs,\n image_target_size=config.image_target_size,\n image_input_size=config.image_input_size,\n maya_conversion=config.maya_conversion,\n max_value=config.max_depth,\n normalize_labels=config.normalize_labels,\n aux_losses=config.aux_losses,\n selected_joints=config.selected_joints,\n joint_names=config.joint_order,\n num_dims=config.num_dims,\n keep_dims=config.keep_dims,\n mask_occluded_joints=config.mask_occluded_joints,\n background_multiplier=config.background_multiplier,\n augment_background=config.augment_background,\n background_folder=config.background_folder,\n randomize_background=config.randomize_background,\n maya_joint_labels=config.labels,\n babas_tfrecord_dir=train_babas_tfrecord_dir,\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\n image_target_size_is_flipped=config.image_target_size_is_flipped)\n train_data_dict['deconv_label_size'] = len(config.labels)\n\n val_data_dict = inputs(\n tfrecord_file=validation_data,\n batch_size=config.validation_batch,\n im_size=config.resize,\n target_size=config.image_target_size,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n label_shape=config.num_classes,\n num_epochs=config.epochs,\n image_target_size=config.image_target_size,\n image_input_size=config.image_input_size,\n maya_conversion=config.maya_conversion,\n max_value=config.max_depth,\n normalize_labels=config.normalize_labels,\n aux_losses=config.aux_losses,\n selected_joints=config.selected_joints,\n joint_names=config.joint_order,\n num_dims=config.num_dims,\n keep_dims=config.keep_dims,\n mask_occluded_joints=config.mask_occluded_joints,\n background_multiplier=config.background_multiplier,\n augment_background='none',\n background_folder=config.background_folder,\n randomize_background=None,\n maya_joint_labels=config.labels,\n babas_tfrecord_dir=val_babas_tfrecord_dir,\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\n image_target_size_is_flipped=config.image_target_size_is_flipped)\n val_data_dict['deconv_label_size'] = len(config.labels)\n\n # Check output_shape\n if config.selected_joints is not None:\n print 'Targeting joint: %s' % config.selected_joints\n joint_shape = len(config.selected_joints) * config.keep_dims\n if (config.num_classes // config.keep_dims) > (joint_shape):\n print 'New target size: %s' % joint_shape\n config.num_classes = joint_shape\n\n with tf.device('/gpu:0'):\n with tf.variable_scope('cnn') as scope:\n print 'Creating training graph:'\n model = model_file.model_struct(\n weight_npy_path=config.weight_npy_path)\n train_mode = tf.get_variable(name='training', initializer=True)\n model.build(\n rgb=train_data_dict['image'],\n target_variables=train_data_dict,\n train_mode=train_mode,\n batchnorm=config.batch_norm)\n train_mu, train_var = tf.nn.moments(train_data_dict['image'], axes=[1, 2, 3])\n tf.summary.histogram(\"train image mean\", train_mu)\n tf.summary.histogram(\"train image std\", tf.sqrt(train_var))\n if 'deconv_image' in config.aux_losses:\n tf.summary.image('Deconv train', model.deconv)\n if 'deconv_label' in config.aux_losses:\n tf.summary.image(\n 'Deconv label train',\n tf.expand_dims(\n tf.cast(\n tf.argmax(model.deconv, axis=3), tf.float32), 3))\n\n # Setup validation op\n if validation_data is not False:\n scope.reuse_variables()\n print 'Creating validation graph:'\n val_model = model_file.model_struct()\n val_model.build(\n rgb=val_data_dict['image'],\n target_variables=val_data_dict)\n\n # Calculate validation accuracy\n val_mu, val_var = tf.nn.moments(val_data_dict['image'], axes=[1, 2, 3])\n tf.summary.histogram(\"validation image mean\", val_mu)\n tf.summary.histogram(\"validation image std\", tf.sqrt(val_var))\n if 'label' in val_data_dict.keys():\n # val_score = tf.reduce_mean(\n # tf_fun.l2_loss(\n # val_model.output, val_data_dict['label']))\n if config.keep_dims == 3:\n z_mask = tf.expand_dims(tf.tile([1, 1, 0], [int(val_data_dict['label'].get_shape()[-1]) // 3]), axis=0)\n z_mask = tf.cast(z_mask, tf.float32)\n val_model.output = val_model.output * z_mask\n val_data_dict['label'] = val_data_dict['label'] * z_mask \n val_score = tf.reduce_mean(tf.nn.l2_loss(val_model.output - val_data_dict['label']))\n tf.summary.scalar(\"validation mse\", val_score)\n if 'fc' in config.aux_losses:\n tf.summary.image('FC val activations', val_model.final_fc)\n if 'deconv_image' in config.aux_losses:\n tf.summary.image('Deconv val', val_model.deconv)\n if 'deconv_label' in config.aux_losses:\n tf.summary.image(\n 'Deconv label train',\n tf.expand_dims(\n tf.cast(\n tf.argmax(val_model.deconv, axis=3),\n tf.float32), 3))\n tf.summary.image(\n 'validation images',\n tf.cast(val_data_dict['image'], tf.float32))\n\n # Prepare the loss functions:::\n loss_list, loss_label = [], []\n if 'label' in train_data_dict.keys():\n # 1. Joint localization loss\n if config.calculate_per_joint_loss == 'thomas':\n label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\n model=model,\n train_data_dict=train_data_dict,\n config=config,\n y_key='label',\n yhat_key='output')\n loss_list += [label_loss]\n elif config.calculate_per_joint_loss == 'skeleton':\n label_loss = tf_fun.skeleton_loss(\n model=model,\n train_data_dict=train_data_dict,\n config=config,\n y_key='label',\n yhat_key='output')\n loss_list += [label_loss]\n elif config.calculate_per_joint_loss == 'skeleton and joint':\n label_loss = tf_fun.skeleton_loss(\n model=model,\n train_data_dict=train_data_dict,\n config=config,\n y_key='label',\n yhat_key='output')\n loss_list += [label_loss]\n loss_label += ['skeleton loss']\n delta = model['output'] - train_data_dict['label']\n proc_weights = np.asarray(\n config.dim_weight)[None,:].repeat(\n len(config.joint_names), axis=0).reshape(1, -1)\n delta *= proc_weights\n # label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\n # model=model,\n # train_data_dict=train_data_dict,\n # config=config,\n # y_key='label',\n # yhat_key='output')\n # loss_list += [label_loss]\n loss_list += [tf.nn.l2_loss(\n model['output'] - train_data_dict['label'])]\n else:\n loss_list += [tf.nn.l2_loss(\n model['output'] - train_data_dict['label'])]\n loss_label += ['combined head']\n for al in loss_helper.potential_aux_losses():\n loss_list, loss_label = loss_helper.get_aux_losses(\n loss_list=loss_list,\n loss_label=loss_label,\n train_data_dict=train_data_dict,\n model=model,\n aux_loss_dict=al,\n domain_adaptation=train_babas_tfrecord_dir)\n loss = tf.add_n(loss_list)\n\n # Add wd if necessary\n if config.wd_penalty is not None:\n _, l2_wd_layers = tf_fun.fine_tune_prepare_layers(\n tf.trainable_variables(), config.wd_layers)\n l2_wd_layers = [\n x for x in l2_wd_layers if 'biases' not in x.name]\n if config.wd_type == 'l1':\n loss += (config.wd_penalty * tf.add_n(\n [tf.reduce_sum(tf.abs(x)) for x in l2_wd_layers]))\n elif config.wd_type == 'l2':\n loss += (config.wd_penalty * tf.add_n(\n [tf.nn.l2_loss(x) for x in l2_wd_layers]))\n\n optimizer = loss_helper.return_optimizer(config.optimizer)\n optimizer = optimizer(config.lr)\n\n if hasattr(config, 'fine_tune_layers') and config.fine_tune_layers is not None:\n print 'Finetuning learning for: %s' % config.fine_tune_layers\n train_op, grads = tf_fun.finetune_learning(\n loss,\n trainables=tf.trainable_variables(),\n fine_tune_layers=config.fine_tune_layers,\n config=config\n )\n else:\n # Op to calculate every variable gradient\n grads = optimizer.compute_gradients(\n loss, tf.trainable_variables())\n # Op to update all variables according to their gradient\n train_op = optimizer.apply_gradients(\n grads_and_vars=grads)\n\n # Summarize all gradients and weights\n [tf.summary.histogram(\n var.name + '/gradient', grad)\n for grad, var in grads if grad is not None]\n # train_op = optimizer.minimize(loss)\n\n # Summarize losses\n [tf.summary.scalar(lab, il) for lab, il in zip(\n loss_label, loss_list)]\n\n # Summarize images and l1 weights\n tf.summary.image(\n 'train images',\n tf.cast(train_data_dict['image'], tf.float32))\n tf_fun.add_filter_summary(\n trainables=tf.trainable_variables(),\n target_layer='conv1_1_filters')\n\n # Set up summaries and saver\n saver = tf.train.Saver(\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\n summary_op = tf.summary.merge_all()\n tf.add_to_collection('output', model.output)\n\n # Initialize the graph\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\n\n # Need to initialize both of these if supplying num_epochs to inputs\n sess.run(tf.group(tf.global_variables_initializer(),\n tf.local_variables_initializer()))\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\n\n # Set up exemplar threading\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n\n # Create list of variables to run through training model\n train_session_vars = {\n 'train_op': train_op,\n 'loss_value': loss,\n 'im': train_data_dict['image'],\n 'yhat': model.output,\n 'ytrue': train_data_dict['label']\n }\n if hasattr(model, 'deconv'):\n train_session_vars['deconv'] = model.deconv\n if hasattr(model, 'final_fc'):\n train_session_vars['fc'] = model.final_fc\n\n # Create list of variables to run through validation model\n val_session_vars = {\n 'val_acc': val_score,\n 'val_pred': val_model.output,\n 'val_ims': val_data_dict['image'],\n 'val_true': val_data_dict['label'],\n }\n\n # Create list of variables to save to numpys\n save_training_vars = [\n 'im',\n 'yhat',\n 'ytrue',\n 'yhat'\n ]\n\n for al in loss_helper.potential_aux_losses():\n if al.keys()[0] in train_data_dict.keys():\n y_key = '%s' % al.keys()[0]\n train_session_vars[y_key] = train_data_dict[al.values()[0]['y_name']]\n save_training_vars += [y_key]\n\n yhat_key = '%s_hat' % al.keys()[0]\n train_session_vars[yhat_key] = model[al.values()[0]['model_name']]\n save_training_vars += [yhat_key]\n\n # Start training loop\n np.save(config.train_checkpoint, config)\n step, losses = 0, []\n num_joints = int(\n train_data_dict['label'].get_shape()[-1]) // config.keep_dims\n normalize_vec = tf_fun.get_normalization_vec(config, num_joints)\n if config.resume_from_checkpoint is not None:\n if '.ckpt' in config.resume_from_checkpoint:\n ckpt = config.resume_from_checkpoint\n 'Restoring specified checkpoint: %s' % config.resume_from_checkpoint\n else:\n ckpt = tf.train.latest_checkpoint(config.resume_from_checkpoint)\n print 'Evaluating checkpoint: %s' % ckpt\n saver.restore(sess, ckpt)\n try:\n while not coord.should_stop():\n start_time = time.time()\n train_out_dict = sess.run(train_session_vars.values())\n train_out_dict = {k: v for k, v in zip(\n train_session_vars.keys(), train_out_dict)}\n losses.append(train_out_dict['loss_value'])\n duration = time.time() - start_time\n assert not np.isnan(\n train_out_dict['loss_value']), 'Model diverged with loss = NaN'\n if step % config.steps_before_validation == 0:\n if validation_data is not False:\n val_out_dict = sess.run(\n val_session_vars.values())\n val_out_dict = {k: v for k, v in zip(\n val_session_vars.keys(), val_out_dict)}\n # if config.normalize_labels:\n # val_out_dict['val_pred'] *= normalize_vec\n # val_out_dict['val_true'] *= normalize_vec\n np.savez(\n os.path.join(\n results_dir, '%s_val_coors' % step),\n val_pred=val_out_dict['val_pred'],\n val_ims=val_out_dict['val_ims'],\n val_true=val_out_dict['val_true'],\n normalize_vec=normalize_vec)\n with open(\n os.path.join(\n results_dir, '%s_config.p' % step), 'wb') as fp:\n pickle.dump(config, fp)\n\n # Summaries\n summary_str = sess.run(summary_op)\n summary_writer.add_summary(summary_str, step)\n\n # Training status and validation accuracy attach 9177\n format_str = (\n '%s: step %d, loss = %.8f (%.1f examples/sec; '\n '%.3f sec/batch) | '\n 'Validation l2 loss = %s | logdir = %s')\n print (format_str % (\n datetime.now(), step, train_out_dict['loss_value'],\n config.train_batch / duration, float(duration),\n val_out_dict['val_acc'],\n config.summary_dir))\n\n # Save the model checkpoint if it's the best yet\n if config.normalize_labels:\n train_out_dict['yhat'] *= normalize_vec\n train_out_dict['ytrue'] *= normalize_vec\n [save_training_data(\n output_dir=results_dir,\n data=train_out_dict[k],\n name='%s_%s' % (k, step)) for k in save_training_vars]\n saver.save(\n sess, os.path.join(\n config.train_checkpoint,\n 'model_' + str(step) + '.ckpt'), global_step=step)\n\n else:\n # Training status\n format_str = ('%s: step %d, loss = %.8f (%.1f examples/sec; '\n '%.3f sec/batch)')\n print (format_str % (\n datetime.now(),\n step,\n train_out_dict['loss_value'],\n config.train_batch / duration,\n float(duration)))\n # End iteration\n step += 1\n\n except tf.errors.OutOfRangeError:\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\n finally:\n coord.request_stop()\n dt_stamp = get_dt() # date-time stamp\n np.save(\n os.path.join(\n config.tfrecord_dir, '%s_training_loss' % dt_stamp), losses)\n coord.join(threads)\n sess.close()","def load_ckpt(self, name=None):\r\n name = name if name == 'latest' else \"ckpt_epoch{}\".format(name)\r\n load_path = os.path.join(self.model_dir, \"{}.pth\".format(name))\r\n if not os.path.exists(load_path):\r\n raise ValueError(\"Checkpoint {} not exists.\".format(load_path))\r\n\r\n checkpoint = torch.load(load_path)\r\n print(\"Checkpoint loaded from {}\".format(load_path))\r\n if isinstance(self.net, nn.DataParallel):\r\n self.net.module.load_state_dict(checkpoint['model_state_dict'])\r\n else:\r\n self.net.load_state_dict(checkpoint['model_state_dict'])\r\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\r\n self.scheduler.load_state_dict(checkpoint['scheduler_state_dict'])\r\n self.clock.restore_checkpoint(checkpoint['clock'])","def initialize_model_from_cfg(args, gpu_id=0):\n model = eval(args.model).loot_model(args)\n model.eval()\n\n if args.cuda:\n model.cuda()\n\n if args.load_ckpt:\n load_name = args.load_ckpt\n logger.info(\"loading checkpoint %s\", load_name)\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\n net_utils.load_ckpt(model, checkpoint['model'])\n\n if args.load_detectron:\n logger.info(\"loading detectron weights %s\", args.load_detectron)\n load_detectron_weight(model, args.load_detectron)\n\n\n return model","def load_model(path, model, optimizer):\n print(\"LOADING MODEL...\")\n ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)\n status = ckpt.restore(tf.train.latest_checkpoint(path))\n ckpt_manager = tf.train.CheckpointManager(\n checkpoint=ckpt, \n directory=FLAGS.model_dir, \n max_to_keep=3 \n )\n return model, optimizer, ckpt, ckpt_manager","def train_and_evaluate(\n model_name: str,\n job_log_dir: Optional[str],\n multi_host_checkpointing: Optional[bool],\n maybe_use_persistence_checkpointing: bool,\n restore_checkpoint_dir: Optional[str],\n restore_checkpoint_step: Optional[int],\n eval_on_test: Optional[bool],\n checkpoint_todelete_subdir: Optional[str] = None) -> None:\n model_config = model_utils.get_model(model_name)()\n _write_params_file(model_config, job_log_dir)\n task_p = model_config.task()\n\n input_p = model_config.datasets()\n # Note that we modify input params below with runtime information, therefore\n # model_config.dataset() should not be called again as it won't have the\n # correct runtime information populated.\n for inp in input_p:\n if not isinstance(inp, base_input.BaseInputParams):\n raise ValueError('Expecting BaseInputParams from datasets(), got: '\n f'{inp.ToText()}')\n inp.num_infeed_hosts = jax.process_count()\n inp.infeed_host_index = jax.process_index()\n train_input_p = [v for v in input_p if v.is_training]\n if len(train_input_p) != 1:\n raise ValueError(\n f'Expecting exactly one training split. Got `{len(train_input_p)}`.')\n train_input_p = train_input_p[0]\n logging.info('train_input_p=%s', train_input_p.ToText())\n eval_input_p = None\n if eval_on_test:\n eval_input_p = [v for v in input_p if not v.is_training]\n\n checkpoint_type = checkpoints.retrieve_checkpoint_type(\n multi_host_checkpointing, maybe_use_persistence_checkpointing, task_p)\n\n checkpoint_manager = _create_checkpoint_manager(model_name, task_p,\n job_log_dir, checkpoint_type,\n checkpoint_todelete_subdir)\n\n if task_p.model.device_mesh is not None:\n train_and_evaluate_spmd_model(task_p, train_input_p, job_log_dir,\n checkpoint_manager, checkpoint_type,\n restore_checkpoint_dir,\n restore_checkpoint_step, eval_input_p)\n else:\n train_and_evaluate_pmap(task_p, train_input_p, job_log_dir,\n checkpoint_manager, restore_checkpoint_dir,\n restore_checkpoint_step, eval_input_p)","def _setup_training(self, params, **kwargs):\n model_params = params.permute_training_on_top().model\n\n model_kwargs = {**model_params.fixed, **model_params.variable}\n\n model = self.model_cls(**model_kwargs)\n\n training_params = params.permute_training_on_top().training\n losses = training_params.nested_get(\"losses\")\n optimizer_cls = training_params.nested_get(\"optimizer_cls\")\n optimizer_params = training_params.nested_get(\"optimizer_params\")\n train_metrics = training_params.nested_get(\"train_metrics\", {})\n lr_scheduler_cls = training_params.nested_get(\"lr_sched_cls\", None)\n lr_scheduler_params = training_params.nested_get(\"lr_sched_params\",\n {})\n val_metrics = training_params.nested_get(\"val_metrics\", {})\n\n # necessary for resuming training from a given path\n save_path = kwargs.pop(\"save_path\", os.path.join(\n self.save_path,\n \"checkpoints\",\n \"run_%02d\" % self._run))\n\n return self.trainer_cls(\n network=model,\n save_path=save_path,\n losses=losses,\n key_mapping=self.key_mapping,\n optimizer_cls=optimizer_cls,\n optimizer_params=optimizer_params,\n train_metrics=train_metrics,\n val_metrics=val_metrics,\n lr_scheduler_cls=lr_scheduler_cls,\n lr_scheduler_params=lr_scheduler_params,\n optim_fn=self._optim_builder,\n save_freq=self.checkpoint_freq,\n **kwargs\n )","def create_or_load_model(model, model_dir, session, name):\n latest_ckpt = tf.train.latest_checkpoint(model_dir)\n if latest_ckpt:\n start_time = time.time()\n # It only takes a few seconds to initialize all variables.\n session.run(tf.global_variables_initializer())\n logging.info(\n \"Initialize %s model with fresh parameters before loading variables \"\n \"from the checkpoint, time %.2fs\", name,\n time.time() - start_time)\n model = load_model(model, latest_ckpt, session, name)\n else:\n start_time = time.time()\n session.run(tf.global_variables_initializer())\n session.run(tf.tables_initializer())\n utils.print_out(\" created %s model with fresh parameters, time %.2fs\" %\n (name, time.time() - start_time))\n\n global_step = model.global_step.eval(session=session)\n return model, global_step","def load_checkpoint(path: str, save_dir: str, cuda: bool = False, attention_viz: bool = False) -> nn.Module:\r\n # Load model and args\r\n state = torch.load(path, map_location=lambda storage, loc: storage)\r\n args, loaded_state_dict = state['args'], state['state_dict']\r\n\r\n # Update args with current args\r\n args.cuda = cuda\r\n args.attention_viz = attention_viz\r\n args.save_dir = save_dir\r\n\r\n model = build_model(args)\r\n model.load_state_dict(loaded_state_dict)\r\n\r\n if cuda:\r\n print('Moving model to cuda')\r\n model = model.cuda()\r\n\r\n return model","def load_from_checkpoint(results_dir, load_fn, args):\n ckpt_dir = os.path.join(results_dir, \"tb\", \"version_0\", \"checkpoints\")\n files = os.listdir(ckpt_dir)\n assert len(files) > 0, \"Checkpoint directory is empty\"\n ckpt_path = os.path.join(ckpt_dir, files[-1])\n model = load_fn(checkpoint_path=ckpt_path, args=args)\n return model","def load_checkpoint(model, model_name='model', validation_id=None):\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\n _load_model(model.module if type(model) is torch.nn.DataParallel else model, model_name, path=path, reload=True)","def load_checkpoint(self, session, model_dir):\n assert self.params.cp_load == True, (\"cp_load must be set to true to load a checkpoint\")\n self.loader.restore(session, model_dir)","def try_create_model_load_from_checkpoint_and_adjust(self) -> bool:\n success = self.try_create_model_and_load_from_checkpoint()\n self.create_summary_and_adjust_model_for_gpus()\n return success","def try_load_checkpoint_for_model(self) -> bool:\n if self._model is None:\n raise ValueError(\"Model must be created before it can be adjusted.\")\n\n if not self.checkpoint_path:\n raise ValueError(\"No checkpoint provided\")\n\n if not self.checkpoint_path.is_file():\n logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')\n return False\n\n epoch = ModelAndInfo._load_checkpoint(model=self._model,\n checkpoint_path=self.checkpoint_path,\n key_in_state_dict=ModelAndInfo.MODEL_STATE_DICT_KEY,\n use_gpu=self.config.use_gpu)\n\n logging.info(f\"Loaded model from checkpoint (epoch: {epoch})\")\n self.checkpoint_epoch = epoch\n return True","def load_checkpoint(self, label):\n model_dir = os.path.join(\n config.results_dir, config.experiment_name, 'checkpoints')\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\n\n print(\"Loading model from {}\".format(model_file))\n model_dict = torch.load(model_file)\n\n self.use_cuda = model_dict['use_cuda']\n if self.use_cuda:\n self.net.cuda()\n\n self.net.load_state_dict(model_dict['net_state_dict'])","def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\n print(\"Load checkpoint from: {}\".format(path))\n state_dict, optimizer_state = _load(path)\n\n model.load_dict(state_dict)\n if not reset_optimizer and optimizer is not None:\n if optimizer_state is not None:\n print(\"[loading] Load optimizer state from {}\".format(path))\n optimizer.load(optimizer_state)\n\n return model","def load_checkpoints(args, model): \n print('Loading the model checkpoints from iter {}...'.format(args.resume_iter))\n checkpoint_path = os.path.join(config.checkpoint_path, args.model_type)\n\n gen_g_path = os.path.join(checkpoint_path, '{}-Gen_g.ckpt'.format(args.resume_iter))\n gen_f_path = os.path.join(checkpoint_path, '{}-Gen_f.ckpt'.format(args.resume_iter))\n model.gen_g.load_state_dict(torch.load(gen_g_path, map_location=lambda storage, loc: storage))\n model.gen_f.load_state_dict(torch.load(gen_f_path, map_location=lambda storage, loc: storage))\n\n if args.train:\n dis_c_path = os.path.join(checkpoint_path, '{}-Dis_c.ckpt'.format(args.resume_iter))\n dis_t_path = os.path.join(checkpoint_path, '{}-Dis_t.ckpt'.format(args.resume_iter))\n model.dis_c.load_state_dict(torch.load(dis_c_path, map_location=lambda storage, loc: storage))\n model.dis_t.load_state_dict(torch.load(dis_t_path, map_location=lambda storage, loc: storage))","def load_model (checkpoint_path, model, opt_fn=None, loss_fn=None, epoch=None):\n\n if not os.path.exists(checkpoint_path):\n raise Exception (\"The {} does not exist!\".format(checkpoint_path))\n\n ckpt = torch.load(checkpoint_path)\n model.load_state_dict(ckpt['model_state_dict'])\n\n if opt_fn is not None and loss_fn is not None:\n opt_fn.load_state_dict(ckpt['optimizer_state_dict'])\n epoch = ckpt['epoch']\n loss_fn = ckpt['loss']\n return model, opt_fn, loss_fn, epoch\n else:\n return model","def train(model, infer_train, infer_val, load_checkpoint=None):\n\n global checkpoint_name\n print('Initialising {}'.format(cfg['experiment_name']))\n checkpoint_folder = 'checkpoints/{}/'.format(cfg['experiment_name'])\n\n if not os.path.exists(checkpoint_folder):\n os.makedirs(checkpoint_folder)\n\n tb_folder = 'tb/{}/'.format(cfg['experiment_name'])\n if not os.path.exists(tb_folder):\n os.makedirs(tb_folder)\n\n writer = SummaryWriter(logdir=tb_folder, flush_secs=30)\n optimiser = Adam(model.parameters(), lr=cfg['learning_rate'], weight_decay=cfg['weight_decay'])\n\n train_dataset = TweetDataset(dataset_type='train')\n train_loader = DataLoader(train_dataset, batch_size=cfg['batch_size'], num_workers=cfg['workers'],\n collate_fn=collate_function, shuffle=True, pin_memory=True)\n\n val_dataset = TweetDataset(dataset_type='val')\n val_loader = DataLoader(val_dataset, batch_size=cfg['batch_size'], num_workers=cfg['workers'],\n collate_fn=collate_function, shuffle=False, pin_memory=True)\n\n if load_checkpoint:\n checkpoint = torch.load(load_checkpoint)\n assert model.config == checkpoint['net_config'], \\\n \"The provided checkpoint has a different configuration, loading is impossible\"\n start_epoch = checkpoint['epoch'] + 1\n epochs = cfg['epochs'] + start_epoch\n step = checkpoint['step']\n model.load_state_dict(checkpoint['model'])\n optimiser.load_state_dict(checkpoint['optimiser'])\n print(\"Loaded the checkpoint at {}\".format(load_checkpoint))\n else:\n start_epoch, step = 0, 0\n epochs = cfg['epochs']\n\n init_loss = 0.\n avg_loss = AverageMeter()\n best_mae = 1e10\n\n print('Sanity val')\n val(model, val_loader, writer, 0, infer_val)\n model.train()\n\n print('Starting training')\n for epoch in range(start_epoch, epochs):\n loader_length = len(train_loader)\n epoch_start = time.time()\n\n for batch_idx, batch in enumerate(train_loader):\n optimiser.zero_grad()\n\n loss = infer_train(model, batch)\n loss.backward()\n\n if epoch == 0 and batch_idx == 0:\n init_loss = loss\n\n # logging\n elapsed = time.time() - epoch_start\n progress = batch_idx / loader_length\n est = datetime.timedelta(seconds=int(elapsed / progress)) if progress > 0.001 else '-'\n avg_loss.update(loss)\n suffix = '\\tloss {:.4f}/{:.4f}\\tETA [{}/{}]'.format(avg_loss.avg, init_loss,\n datetime.timedelta(seconds=int(elapsed)), est)\n printProgressBar(batch_idx, loader_length, suffix=suffix,\n prefix='Epoch [{}/{}]\\tStep [{}/{}]'.format(epoch, epochs - 1, batch_idx, loader_length))\n\n writer.add_scalar('Steps/train_loss', loss, step)\n\n # saving the model\n if step % cfg['checkpoint_every'] == 0:\n checkpoint_name = '{}/epoch_{}.pth'.format(checkpoint_folder, epoch)\n torch.save({'model': model.state_dict(), 'epoch': epoch, 'batch_idx': batch_idx, 'step': step,\n 'optimiser': optimiser.state_dict(), 'train_config': cfg, 'net_config': model.config,\n 'dataset_config': DATASET_CONFIG},\n checkpoint_name)\n step += 1\n optimiser.step()\n\n # validating\n if step % cfg['val_every'] == 0:\n mae = val(model, val_loader, writer, step, infer_val)\n if mae < best_mae:\n best_mae = mae\n print('Best model with V{:.2f}'.format(best_mae))\n torch.save({'model': model.state_dict(), 'epoch': epoch, 'batch_idx': batch_idx, 'step': step,\n 'optimiser': optimiser.state_dict(), 'train_config': cfg, 'net_config': model.config,\n 'dataset_config': DATASET_CONFIG},\n '{}/best.pth'.format(checkpoint_folder))\n model.train()\n\n # end of epoch\n print('')\n writer.add_scalar('Epochs/train_loss', avg_loss.avg, epoch)\n avg_loss.reset()\n checkpoint_name = '{}/epoch_{}.pth'.format(checkpoint_folder, epoch)\n torch.save({'model': model.state_dict(), 'epoch': epoch, 'batch_idx': loader_length, 'step': step,\n 'optimiser': optimiser.state_dict(), 'train_config': cfg, 'net_config': model.config,\n 'dataset_config': DATASET_CONFIG},\n checkpoint_name)\n\n # finished training\n writer.close()\n print('Training finished :)')","def load_pretrained_model(self,model_dir):\n rnn_params = json.load(open(os.path.join(model_dir,\n \"./model.json\")))[\"rnn\"]\n\n logging.info(\"Loading model from: {}\".format(model_dir))\n self.create_training_model(model_dir = model_dir,\n **rnn_params)\n #从目录中读取神经网络参数\n self.set_model_from_file()","def load_checkpoint(self, model, optimizers):\n self.epoch = get_last_epoch(self.log_path)\n\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\n model.load_state_dict(model_state_dict)\n\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\n for opt_ind in range(len(optimizers)):\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\n\n schedulers = load_sched(optimizers, self.epoch)\n\n return model, optimizers, schedulers","def load_checkpoint(cfg, args):\n checkpoint_iteration = args.checkpoint\n bucket = connect_to_bucket(args.bucket)\n # load actual checkpoint\n if not os.path.isdir(cfg.OUTPUT_DIR):\n os.mkdir(cfg.OUTPUT_DIR)\n blob = bucket.blob(cfg.OUTPUT_DIR + \"/model_\" + str(checkpoint_iteration) + \".pth\")\n blob.download_to_filename(cfg.OUTPUT_DIR + \"/model_\" + str(checkpoint_iteration) + \".pth\")\n if args.resume:\n # also write last checkpoint file for when --resume statement, model gets checkpoint name from this file\n with open(cfg.OUTPUT_DIR + \"/last_checkpoint\", \"w\") as file:\n file.write(\"model_\" + str(checkpoint_iteration) + \".pth\")\n # return statement not clean, but useful for inference code\n return checkpoint_iteration, bucket","def load_model(config, batchmanager):\n \n # this function returns a dictionary mapping\n # name of the task (string) --> number of classes in the task (int)\n tasks = batchmanager.getTasksWithNClasses()\n # this \"tasks\" object is used to initialize the model (with the right output layers)\n model = MultiTaskBERT(device = config.device, tasks = tasks)\n\n if not config.untrained_baseline:\n\n # if we evaluate only, model MUST be loaded.\n if config.k_shot_only:\n try :\n model.load_state_dict(torch.load(path_to_dicts(config), map_location = config.device))\n except Exception:\n print(f\"WARNING: the `--k_shot_only` flag was passed, but `{path_to_dicts(config)}` was NOT found!\")\n raise Exception()\n \n # if we saved the state dictionary, load it.\n elif config.resume:\n try :\n model.load_state_dict(torch.load(path_to_dicts(config), map_location = config.device))\n except Exception:\n print(f\"WARNING: the `--resume` flag was passed, but `{path_to_dicts(config)}` was NOT found!\")\n else:\n if os.path.exists(path_to_dicts(config)):\n print(f\"WARNING: `--resume` flag was NOT passed, but `{path_to_dicts(config)}` was found!\") \n\n return model","def train_model_by_config(\n checkpoint: int,\n config: lmp.config.BaseConfig,\n dataset: lmp.dataset.BaseDataset,\n model: lmp.model.BaseRNNModel,\n optimizer: Union[\n torch.optim.SGD,\n torch.optim.Adam,\n ],\n tokenizer: lmp.tokenizer.BaseTokenizer,\n):\n # Create collate_fn for sampling.\n collate_fn = lmp.dataset.BaseDataset.create_collate_fn(\n tokenizer=tokenizer,\n max_seq_len=config.max_seq_len\n )\n\n # `torch` utility for sampling.\n data_loader = torch.utils.data.DataLoader(\n dataset,\n batch_size=config.batch_size,\n shuffle=True,\n collate_fn=collate_fn\n )\n\n train_model(\n checkpoint=checkpoint,\n checkpoint_step=config.checkpoint_step,\n data_loader=data_loader,\n device=config.device,\n epoch=config.epoch,\n experiment=config.experiment,\n max_norm=config.max_norm,\n model=model,\n optimizer=optimizer,\n vocab_size=tokenizer.vocab_size\n )","def load_model_from_checkpoint(file, device):\r\n\r\n if device == 'cuda':\r\n # Load all tensors onto GPU\r\n map_location = lambda storage, loc: storage.cuda()\r\n else:\r\n # Load all tensors onto CPU\r\n map_location = lambda storage, loc: storage\r\n\r\n # Assuming model was trained and checkpoint saved on Linux, but predict.py inference is executed using Windows.\r\n # Then, it is required to implement the following quick fix, because otherwise the exception is raised:\r\n # \"NotImplementedError: cannot instantiate 'PosixPath' on your system\"\r\n # Credits to https://stackoverflow.com/questions/57286486/i-cant-load-my-model-because-i-cant-put-a-posixpath\r\n if type(file) == pathlib.WindowsPath:\r\n tmp_PosixPath = pathlib.PosixPath\r\n pathlib.PosixPath = pathlib.WindowsPath\r\n\r\n parameters = torch.load(file, map_location=map_location)\r\n\r\n # Restore default\r\n if type(file) == pathlib.WindowsPath:\r\n pathlib.WindowsPath = pathlib.PosixPath\r\n pathlib.PosixPath = tmp_PosixPath\r\n\r\n model = train.create_model(parameters)\r\n\r\n model.class_to_idx = parameters.get('train_datasets_class_to_idx')\r\n model.load_state_dict(parameters.get('state_dict'), strict=False)\r\n\r\n return model, parameters","def get_pretrain_model(pretrain_model, target_model, checkpoint='-1'):\n if not os.path.isfile(os.path.join(pretrain_model, \"checkpoint\")):\n sys.exit(\"[ERROR] Cannot find checkpoint in %s.\" % pretrain_model)\n ckpt = tf.train.get_checkpoint_state(pretrain_model)\n\n model_checkpoint_path = ckpt.model_checkpoint_path\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\n\n if not ckpt or not model_checkpoint_path:\n sys.exit(\"[ERROR] Cannot read checkpoint %s.\" % os.path.join(pretrain_model, \"checkpoint\"))\n\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\n steps = sorted(steps)\n\n if checkpoint == \"last\":\n tf.logging.info(\"Load the last saved model.\")\n checkpoint = steps[-1]\n else:\n checkpoint = int(checkpoint)\n if checkpoint == -1:\n tf.logging.info(\"Load the best model according to valid_loss\")\n min_epoch = -1\n min_loss = 1e10\n with open(os.path.join(pretrain_model, \"valid_loss\")) as f:\n for line in f.readlines():\n epoch, loss, eer = line.split(\" \")\n epoch = int(epoch)\n loss = float(loss)\n if loss < min_loss:\n min_loss = loss\n min_epoch = epoch\n # Add 1 to min_epoch since epoch is 0-based\n config_json = os.path.join(pretrain_model, \"config.json\")\n params = Params(config_json)\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\n assert checkpoint in steps, \"The checkpoint %d not in the model directory\" % checkpoint\n\n pretrain_model_checkpoint_path = model_checkpoint_path.rsplit(\"-\", 1)[0] + \"-\" + str(checkpoint)\n tf.logging.info(\"Copy the pre-trained model %s as the fine-tuned initialization\" % pretrain_model_checkpoint_path)\n\n import glob\n for filename in glob.glob(pretrain_model_checkpoint_path + \"*\"):\n bas = os.path.basename(filename).split(\"-\", 1)[0]\n ext = os.path.basename(filename).rsplit(\".\", 1)[1]\n shutil.copyfile(filename, os.path.join(target_model, bas + \"-0.\" + ext))\n\n with open(os.path.join(target_model, \"checkpoint\"), \"w\") as f:\n f.write(\"model_checkpoint_path: \\\"%s\\\"\\n\" % os.path.join(target_model, os.path.basename(model_checkpoint_path).rsplit(\"-\", 1)[0] + \"-0\"))\n f.write(\"all_model_checkpoint_paths: \\\"%s\\\"\\n\" % os.path.join(target_model, os.path.basename(model_checkpoint_path).rsplit(\"-\", 1)[0] + \"-0\"))\n return","def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\n self.model.load_state_dict(checkpoint[\"model_state_dict\"])\n self.optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n return self","def checkpoint_load(checkpoint_path, gpu):\n model_info = torch.load(checkpoint_path)\n model = models.vgg19(pretrained=True)\n for param in model.parameters():\n param.requires_grad = False\n \n model.class_to_idx = model_info['class_to_idx']\n\n model = classifier(model)\n model.load_state_dict(model_info[\"model_state_dict\"])\n return model, model.class_to_idx","def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\n print(\"Loading checkpoint: {}\".format(checkpoint_path))\n state = torch.load(checkpoint_path)\n self.model.load_state_dict(state['state_dict'])\n self.optimizer.load_state_dict(state['optim_dict'])\n\n if continue_from_epoch:\n self.epoch = state['epoch']","def create_reference_model(self, config, tmp_path_factory: pytest.TempPathFactory, *args):\n config = copy.deepcopy(config) # ensure the reference model is not passed to tests\n\n save_folder = tmp_path_factory.mktemp('{device}-{precision}'.format(**config))\n config.update({'save_interval': '1ep', 'save_folder': str(save_folder), 'save_filename': 'ep{epoch}.pt'})\n\n trainer = Trainer(**config)\n trainer.fit()\n\n self.reference_model = trainer.state.model\n self.reference_folder = save_folder","def create_model( session, batch_size ):\n model = linear_model.LinearModel(\n FLAGS.linear_size,\n FLAGS.num_layers,\n FLAGS.residual,\n FLAGS.batch_norm,\n FLAGS.max_norm,\n batch_size,\n FLAGS.learning_rate,\n FLAGS.origin_bc,\n summaries_dir,\n dtype=tf.float16 if FLAGS.use_fp16 else tf.float32)\n\n if FLAGS.load <= 0:\n # Create a new model from scratch\n print(\"Creating model with fresh parameters.\")\n session.run( tf.global_variables_initializer() )\n return model\n\n # Load a previously saved model\n ckpt = tf.train.get_checkpoint_state( train_dir, latest_filename=\"checkpoint\")\n print( \"train_dir\", train_dir )\n\n if ckpt and ckpt.model_checkpoint_path:\n # Check if the specific cpixels = pixels / pixels[2,:]heckpoint exists\n if FLAGS.load > 0:\n if os.path.isfile(os.path.join(train_dir,\"checkpoint-{0}.index\".format(FLAGS.load))):\n ckpt_name = os.path.join( os.path.join(train_dir,\"checkpoint-{0}\".format(FLAGS.load)) )\n else:\n raise ValueError(\"Asked to load checkpoint {0}, but it does not seem to exist\".format(FLAGS.load))\n else:\n ckpt_name = os.path.basename( ckpt.model_checkpoint_path )\n\n print(\"Loading model {0}\".format( ckpt_name ))\n model.saver.restore( session, ckpt.model_checkpoint_path )\n return model\n else:\n print(\"Could not find checkpoint. Aborting.\")\n raise( ValueError, \"Checkpoint {0} does not seem to exist\".format( ckpt.model_checkpoint_path ) )\n\n return model","def main(cfg, logger):\n\n # Initialize parameters\n model_selection_metric = cfg['train']['model_selection_metric']\n\n if cfg['train']['model_selection_mode'] == 'maximize':\n model_selection_sign = 1\n elif cfg['train']['model_selection_mode'] == 'minimize':\n model_selection_sign = -1\n else:\n raise ValueError(\n 'model_selection_mode must be either maximize or minimize.')\n\n # Get data loader\n train_loader = make_data_loader(cfg, phase='train')\n val_loader = make_data_loader(cfg, phase='val')\n\n # Set up tensorboard logger\n tboard_logger = SummaryWriter(os.path.join(cfg['misc']['log_dir'], 'logs'))\n\n # Get model\n model = config.get_model(cfg)\n\n # Get optimizer and trainer\n optimizer = getattr(optim, cfg['optimizer']['alg'])(model.parameters(), lr=cfg['optimizer']['learning_rate'],\n weight_decay=cfg['optimizer']['weight_decay'])\n\n trainer = config.get_trainer(cfg, model, optimizer, tboard_logger)\n\n # Load pre-trained model if existing\n kwargs = {\n 'model': model,\n 'optimizer': optimizer,\n }\n\n checkpoint_io = CheckpointIO(cfg['misc']['log_dir'], initialize_from=cfg['model']['init_from'],\n initialization_file_name=cfg['model']['init_file_name'], **kwargs)\n\n try:\n load_dict = checkpoint_io.load('model.pt')\n except FileExistsError:\n load_dict = dict()\n\n epoch_it = load_dict.get('epoch_it', -1)\n it = load_dict.get('it', -1)\n\n metric_val_best = load_dict.get(\n 'loss_val_best', -model_selection_sign * np.inf)\n\n if metric_val_best == np.inf or metric_val_best == -np.inf:\n metric_val_best = -model_selection_sign * np.inf\n\n logger.info('Current best validation metric ({}): {:.5f}'.format(\n model_selection_metric, metric_val_best))\n\n # Training parameters\n stat_interval = cfg['train']['stat_interval']\n stat_interval = stat_interval if stat_interval > 0 else abs(\n stat_interval * len(train_loader))\n\n chkpt_interval = cfg['train']['chkpt_interval']\n chkpt_interval = chkpt_interval if chkpt_interval > 0 else abs(\n chkpt_interval * len(train_loader))\n\n val_interval = cfg['train']['val_interval']\n val_interval = val_interval if val_interval > 0 else abs(\n val_interval * len(train_loader))\n\n # Print model parameters and model graph\n nparameters = sum(p.numel() for p in model.parameters())\n # print(model)\n logger.info('Total number of parameters: {}'.format(nparameters))\n\n # Training loop\n while epoch_it < cfg['train']['max_epoch']:\n epoch_it += 1\n\n for batch in train_loader:\n it += 1\n loss = trainer.train_step(batch, it)\n tboard_logger.add_scalar('train/loss', loss, it)\n\n # Print output\n if stat_interval != 0 and (it % stat_interval) == 0 and it != 0:\n logger.info('[Epoch {}] it={}, loss={:.4f}'.format(\n epoch_it, it, loss))\n\n # Save checkpoint\n if (chkpt_interval != 0 and (it % chkpt_interval) == 0) and it != 0:\n logger.info('Saving checkpoint')\n checkpoint_io.save('model.pt', epoch_it=epoch_it, it=it,\n loss_val_best=metric_val_best)\n\n # Run validation\n if val_interval != 0 and (it % val_interval) == 0 and it != 0:\n eval_dict = trainer.evaluate(val_loader, it)\n\n metric_val = eval_dict[model_selection_metric]\n logger.info('Validation metric ({}): {:.4f}'.format(\n model_selection_metric, metric_val))\n\n for k, v in eval_dict.items():\n tboard_logger.add_scalar('val/{}'.format(k), v, it)\n\n if model_selection_sign * (metric_val - metric_val_best) > 0:\n metric_val_best = metric_val\n logger.info(\n 'New best model (loss {:.4f})'.format(metric_val_best))\n checkpoint_io.save('model_best.pt', epoch_it=epoch_it, it=it,\n loss_val_best=metric_val_best)\n\n # Quit after the maximum number of epochs is reached\n logger.info('Training completed after {} Epochs ({} it) with best val metric ({})={}'.format(\n epoch_it, it, model_selection_metric, metric_val_best))","def load_checkpoint(self, checkpoint_dir):\r\n\r\n if not os.path.exists(checkpoint_dir):\r\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\r\n\r\n path = os.path.join(checkpoint_dir, 'model.pt')\r\n self.model.load_state_dict(torch.load(path, self.device))\r\n self.update()","def load_checkpoint(self, model):\n print(f\"load model {self.save_model_path}\")\n model.load_state_dict(torch.load(self.save_model_path))","def load_ckp(checkpoint_fpath, model, optimizer, device):\n\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\n model.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n valid_acc = checkpoint['valid_acc'] \n return model, optimizer, checkpoint['epoch'], valid_acc","def _init_model(\n self,\n cfg: ConfigType,\n weights: Optional[str],\n device: str = 'cpu',\n ) -> nn.Module:\n checkpoint: Optional[dict] = None\n if weights is not None:\n checkpoint = _load_checkpoint(weights, map_location='cpu')\n\n if not cfg:\n assert checkpoint is not None\n try:\n # Prefer to get config from `message_hub` since `message_hub`\n # is a more stable module to store all runtime information.\n # However, the early version of MMEngine will not save config\n # in `message_hub`, so we will try to load config from `meta`.\n cfg_string = checkpoint['message_hub']['runtime_info']['cfg']\n except KeyError:\n assert 'meta' in checkpoint, (\n 'If model(config) is not provided, the checkpoint must'\n 'contain the config string in `meta` or `message_hub`, '\n 'but both `meta` and `message_hub` are not found in the '\n 'checkpoint.')\n meta = checkpoint['meta']\n if 'cfg' in meta:\n cfg_string = meta['cfg']\n else:\n raise ValueError(\n 'Cannot find the config in the checkpoint.')\n cfg.update(\n Config.fromstring(cfg_string, file_format='.py')._cfg_dict)\n\n # Delete the `pretrained` field to prevent model from loading the\n # the pretrained weights unnecessarily.\n if cfg.model.get('pretrained') is not None:\n del cfg.model.pretrained\n\n model = MODELS.build(cfg.model)\n model.cfg = cfg\n self._load_weights_to_model(model, checkpoint, cfg)\n model.to(device)\n model.eval()\n return model","def get_checkpoint(model, checkpoint='-1'):\n if not os.path.isfile(os.path.join(model, \"checkpoint\")):\n sys.exit(\"[ERROR] Cannot find checkpoint in %s.\" % model)\n ckpt = tf.train.get_checkpoint_state(model)\n\n model_checkpoint_path = ckpt.model_checkpoint_path\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\n\n if not ckpt or not model_checkpoint_path:\n sys.exit(\"[ERROR] Cannot read checkpoint %s.\" % os.path.join(model, \"checkpoint\"))\n\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\n steps = sorted(steps)\n if checkpoint == \"last\":\n tf.logging.info(\"Load the last saved model.\")\n checkpoint = steps[-1]\n else:\n checkpoint = int(checkpoint)\n if checkpoint == -1:\n tf.logging.info(\"Load the best model according to valid_loss\")\n min_epoch = -1\n min_loss = 1e10\n with open(os.path.join(model, \"valid_loss\")) as f:\n for line in f.readlines():\n epoch, loss, eer = line.split(\" \")\n epoch = int(epoch)\n loss = float(loss)\n if loss < min_loss:\n min_loss = loss\n min_epoch = epoch\n # Add 1 to min_epoch since epoch is 0-based\n config_json = os.path.join(model, \"config.json\")\n params = Params(config_json)\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\n tf.logging.info(\"The checkpoint is %d\" % checkpoint)\n assert checkpoint in steps, \"The checkpoint %d not in the model directory\" % checkpoint\n\n model_checkpoint_path = model_checkpoint_path.rsplit(\"-\", 1)[0] + \"-\" + str(checkpoint)\n model_checkpoint_path = os.path.join(model, os.path.basename(model_checkpoint_path))\n\n with open(os.path.join(model, \"checkpoint\"), \"w\") as f:\n f.write(\"model_checkpoint_path: \\\"%s\\\"\\n\" % model_checkpoint_path)\n for checkpoint in all_model_checkpoint_paths:\n checkpoint_new = os.path.join(model, os.path.basename(checkpoint))\n f.write(\"all_model_checkpoint_paths: \\\"%s\\\"\\n\" % checkpoint_new)\n return model_checkpoint_path","def load_pretrained_model(self, model_path):\n # My eyes and my heart both hurt when writing this method\n\n # Only care about layer_types that have trainable parameters\n ltypes = ['BNData', 'ConvolutionData', 'HoleConvolutionData']\n\n def _get_layer_params(layer, ltype):\n\n if ltype == 'BNData': \n n_channels = layer.blobs[0].shape.dim[1]\n gamma = np.array(layer.blobs[0].data).reshape(n_channels)\n beta = np.array(layer.blobs[1].data).reshape(n_channels)\n mean = np.array(layer.blobs[2].data).reshape(n_channels)\n var = np.array(layer.blobs[3].data).reshape(n_channels)\n return [mean, var, gamma, beta]\n\n elif ltype in ['ConvolutionData', 'HoleConvolutionData']:\n is_bias = layer.convolution_param.bias_term\n shape = [int(d) for d in layer.blobs[0].shape.dim]\n weights = np.array(layer.blobs[0].data).reshape(shape)\n bias = []\n if is_bias:\n bias = np.array(layer.blobs[1].data).reshape(shape[0])\n return [weights, bias]\n \n elif ltype == 'InnerProduct':\n raise Exception(\"Fully connected layers {}, not supported\".format(ltype))\n\n else:\n raise Exception(\"Unkown layer type {}\".format(ltype))\n\n\n net = caffe_pb2.NetParameter()\n with open(model_path, 'rb') as model_file:\n net.MergeFromString(model_file.read())\n\n # dict formatted as -> key:<layer_name> :: value:<layer_type>\n layer_types = {}\n # dict formatted as -> key:<layer_name> :: value:[<list_of_params>]\n layer_params = {}\n\n for l in net.layer:\n lname = l.name\n ltype = l.type\n if ltype in ltypes:\n print(\"Processing layer {}\".format(lname))\n layer_types[lname] = ltype\n layer_params[lname] = _get_layer_params(l, ltype)\n\n # Set affine=False for all batchnorm modules\n def _no_affine_bn(module=None):\n if isinstance(module, nn.BatchNorm2d):\n module.affine = False\n\n if len([m for m in module.children()]) > 0:\n for child in module.children():\n _no_affine_bn(child)\n\n #_no_affine_bn(self)\n\n\n def _transfer_conv(layer_name, module):\n weights, bias = layer_params[layer_name]\n w_shape = np.array(module.weight.size())\n \n np.testing.assert_array_equal(weights.shape, w_shape)\n print(\"CONV: Original {} and trans weights {}\".format(w_shape,\n weights.shape))\n module.weight.data = torch.from_numpy(weights)\n\n if len(bias) != 0:\n b_shape = np.array(module.bias.size())\n np.testing.assert_array_equal(bias.shape, b_shape)\n print(\"CONV: Original {} and trans bias {}\".format(b_shape,\n bias.shape))\n module.bias.data = torch.from_numpy(bias)\n\n\n def _transfer_conv_bn(conv_layer_name, mother_module):\n conv_module = mother_module[0]\n bn_module = mother_module[1]\n \n _transfer_conv(conv_layer_name, conv_module)\n \n mean, var, gamma, beta = layer_params[conv_layer_name+'/bn']\n print(\"BN: Original {} and trans weights {}\".format(bn_module.running_mean.size(),\n mean.shape))\n bn_module.running_mean = torch.from_numpy(mean)\n bn_module.running_var = torch.from_numpy(var)\n bn_module.weight.data = torch.from_numpy(gamma)\n bn_module.bias.data = torch.from_numpy(beta)\n\n\n def _transfer_residual(prefix, block):\n block_module, n_layers = block[0], block[1]\n\n bottleneck = block_module.layers[0]\n bottleneck_conv_bn_dic = {prefix + '_1_1x1_reduce': bottleneck.cbr1.cbr_unit,\n prefix + '_1_3x3': bottleneck.cbr2.cbr_unit,\n prefix + '_1_1x1_proj': bottleneck.cb4.cb_unit,\n prefix + '_1_1x1_increase': bottleneck.cb3.cb_unit,}\n\n for k, v in bottleneck_conv_bn_dic.items():\n _transfer_conv_bn(k, v)\n\n for layer_idx in range(2, n_layers+1):\n residual_layer = block_module.layers[layer_idx-1]\n residual_conv_bn_dic = {'_'.join(map(str, [prefix, layer_idx, '1x1_reduce'])): residual_layer.cbr1.cbr_unit,\n '_'.join(map(str, [prefix, layer_idx, '3x3'])): residual_layer.cbr2.cbr_unit,\n '_'.join(map(str, [prefix, layer_idx, '1x1_increase'])): residual_layer.cb3.cb_unit,} \n \n for k, v in residual_conv_bn_dic.items():\n _transfer_conv_bn(k, v)\n\n\n convbn_layer_mapping = {'conv1_1_3x3_s2': self.convbnrelu1_1.cbr_unit,\n 'conv1_2_3x3': self.convbnrelu1_2.cbr_unit,\n 'conv1_3_3x3': self.convbnrelu1_3.cbr_unit,\n 'conv5_3_pool6_conv': self.pyramid_pooling.paths[0].cbr_unit, \n 'conv5_3_pool3_conv': self.pyramid_pooling.paths[1].cbr_unit,\n 'conv5_3_pool2_conv': self.pyramid_pooling.paths[2].cbr_unit,\n 'conv5_3_pool1_conv': self.pyramid_pooling.paths[3].cbr_unit,\n 'conv5_4': self.cbr_final.cbr_unit,}\n\n residual_layers = {'conv2': [self.res_block2, self.block_config[0]],\n 'conv3': [self.res_block3, self.block_config[1]],\n 'conv4': [self.res_block4, self.block_config[2]],\n 'conv5': [self.res_block5, self.block_config[3]],}\n\n # Transfer weights for all non-residual conv+bn layers\n for k, v in convbn_layer_mapping.items():\n _transfer_conv_bn(k, v)\n\n # Transfer weights for final non-bn conv layer\n _transfer_conv('conv6', self.classification)\n\n # Transfer weights for all residual layers\n for k, v in residual_layers.items():\n _transfer_residual(k, v)","def load(self, checkpoint_dir=None):\n\n if checkpoint_dir is None:\n checkpoint_dir = FLAGS.checkpoint_dir\n\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n\n return self.load_from_path(checkpoint_dir)","def load_training_checkpoint(args, model, PATH, ckpt_id):\r\n logger = args.logger\r\n _, checkpoint_state_dict = model.network.load_checkpoint(PATH, ckpt_id)\r\n epoch = checkpoint_state_dict['epoch']\r\n last_global_step = checkpoint_state_dict['last_global_step']\r\n last_global_data_samples = checkpoint_state_dict[\r\n 'last_global_data_samples']\r\n del checkpoint_state_dict\r\n return (epoch, last_global_step, last_global_data_samples)","def load(loadname, checkpoint=None):\n ckpt_dir = \"./models/tf_ckpt_\" + loadname + \"/\"\n if checkpoint is not None:\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\n status.assert_consumed()\n print(\"Loaded checkpoint\")\n else:\n print(\"Not Loading any checkpoint\")\n print(\"Starting training from initial configuration\")","def load_params(self, params):\n params.cp_latest_filename = \"latest_checkpoint_v\"+params.version\n params.cp_load_latest_filename = \"latest_checkpoint_v\"+params.cp_load_ver\n params.cp_load_dir = params.out_dir + params.cp_load_name+ \"/checkpoints/\"\n if not hasattr(params, \"model_out_dir\"):\n params.model_out_dir = params.out_dir + params.model_name\n params.cp_save_dir = params.model_out_dir + \"/checkpoints/\"\n params.log_dir = params.model_out_dir + \"/logfiles/\"\n params.save_dir = params.model_out_dir + \"/savefiles/\"\n params.disp_dir = params.model_out_dir + \"/vis/\"\n params.num_pixels = int(np.prod(params.data_shape))\n self.params = params\n self.params_loaded = True","def checkpoint_model(PATH, ckpt_id, model, epoch, last_global_step,\r\n last_global_data_samples, **kwargs):\r\n checkpoint_state_dict = {\r\n 'epoch': epoch,\r\n 'last_global_step': last_global_step,\r\n 'last_global_data_samples': last_global_data_samples\r\n }\r\n # Add extra kwargs too\r\n checkpoint_state_dict.update(kwargs)\r\n\r\n success = model.network.save_checkpoint(PATH, ckpt_id,\r\n checkpoint_state_dict)\r\n status_msg = 'checkpointing: PATH={}, ckpt_id={}'.format(PATH, ckpt_id)\r\n if success:\r\n logging.info(f\"Success {status_msg}\")\r\n else:\r\n logging.warning(f\"Failure {status_msg}\")\r\n return","def load_model(self, model_path):\n # Check the model file exists\n if not os.path.isfile(model_path):\n raise ValueError(f\"The model file `{model_path}` is not exists or broken!\")\n\n checkpoint = torch.load(model_path)\n self.model_type = checkpoint['model_type']\n self.label2idx = checkpoint['label2idx']\n self.idx2label = checkpoint['idx2label']\n self.model.load_state_dict(checkpoint['model_state_dict'])\n self.model.to(self.device)","def try_create_model_and_load_from_checkpoint(self) -> bool:\n self.create_model()\n if self.checkpoint_path:\n # Load the stored model. If there is no checkpoint present, return immediately.\n return self.try_load_checkpoint_for_model()\n return True","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint)\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load_model(self):\n if os.stat('code/lr-model.pt').st_size == 0:\n return\n params = torch.load('code/lr-model.pt')\n self.set_params(params)","def _load_checkpoint_to_net(config, network):\n if config.existed_ckpt:\n if config.existed_ckpt.endswith(\".npz\"):\n weights = np.load(config.existed_ckpt)\n else:\n weights = load_checkpoint(config.existed_ckpt)\n for param in network.trainable_params():\n weights_name = param.name\n if weights_name not in weights:\n raise ValueError(f\"Param {weights_name} is not found in ckpt file.\")\n\n if isinstance(weights[weights_name], Parameter):\n param.set_data(weights[weights_name].data)\n elif isinstance(weights[weights_name], Tensor):\n param.set_data(Tensor(weights[weights_name].asnumpy(), config.dtype))\n elif isinstance(weights[weights_name], np.ndarray):\n param.set_data(Tensor(weights[weights_name], config.dtype))\n else:\n param.set_data(weights[weights_name])\n else:\n for param in network.trainable_params():\n name = param.name\n value = param.data\n if isinstance(value, Tensor):\n if name.endswith(\".gamma\"):\n param.set_data(one_weight(value.asnumpy().shape))\n elif name.endswith(\".beta\") or name.endswith(\".bias\"):\n if param.data.dtype == \"Float32\":\n param.set_data((weight_variable(value.asnumpy().shape).astype(np.float32)))\n elif param.data.dtype == \"Float16\":\n param.set_data((weight_variable(value.asnumpy().shape).astype(np.float16)))\n else:\n if param.data.dtype == \"Float32\":\n param.set_data(Tensor(weight_variable(value.asnumpy().shape).astype(np.float32)))\n elif param.data.dtype == \"Float16\":\n param.set_data(Tensor(weight_variable(value.asnumpy().shape).astype(np.float16)))","def build_graph_from_config(self, model_config, track_config, checkpoint_path):\n self.build_model()\n \n ema = tf.train.ExponentialMovingAverage(0)\n variables_to_restore = ema.variables_to_restore(moving_avg_variables=[])\n\n # Filter out State variables\n variables_to_restore_filterd = {}\n for key, value in variables_to_restore.items():\n if key.split('/')[1] != 'State':\n if \"alex_branch\" not in key:\n if \"vggf_branch\" not in key:\n variables_to_restore_filterd[key] = value\n \n saver = tf.train.Saver(variables_to_restore_filterd)\n \n\n if osp.isdir(checkpoint_path):\n #checkpoint_path = tf.train.latest_checkpoint(checkpoint_path)\n if not checkpoint_path:\n raise ValueError(\"No checkpoint file found in: {}\".format(checkpoint_path))\n\n def _restore_fn(sess):\n logging.info(\"Loading model from checkpoint: %s\", checkpoint_path)\n saver.restore(sess, checkpoint_path)\n logging.info(\"Successfully loaded checkpoint: %s\", os.path.basename(checkpoint_path))\n logging.info(\"Restore CANet...\")\n\n return _restore_fn","def load_checkpoint(self, checkpoint_path: Union[str, Path]) -> Dict[str, Any]:\n # TODO: move to CheckpointIO\n torch.cuda.empty_cache()\n checkpoint_path = inject_model_parallel_rank(checkpoint_path)\n return self.checkpoint_io.load_checkpoint(checkpoint_path)","def train_model(self):\n self.logger.info('Loading the data...')\n train_data = self.load_data(split=\"train\")\n dev_data = self.load_data(split=\"dev\")\n self.config.best_model = os.path.join(self.config.output_dir,\"best_model\")\n self.logger.info('Training the model, outputdir=%s...,best_model=%s' % (self.config.output_dir,self.config.best_model))\n\n train_params = {\n \"overwrite_output_dir\" : True,\n \"reprocess_input_data\": True,\n \"learning_rate\" : self.config.learning_rate,\n \"num_train_epochs\" : self.config.num_train_epochs,\n \"train_batch_size\" : self.config.train_batch_size,\n \"eval_batch_size\" : self.config.eval_batch_size,\n \"gradient_accumulation_steps\": self.config.gradient_accumulation_steps,\n \"use_early_stopping\" : self.config.early_stopping,\n \"fp16\" : False,\n \"classification_report\" : True,\n \"evaluate_during_training\" : True,\n \"evaluate_during_training_verbose\" : True,\n \"best_model_dir\": self.config.best_model,\n \"save_model_every_epoch\" : self.config.save_model_every_epoch,\n \"save_steps\" : self.config.save_steps,\n \"save_optimizer_and_scheduler\" : self.config.save_optimizer_and_scheduler,\n \"save_best_model\": True,\n }\n\n ## train the model \n self.model.train_model(\n train_data,\n eval_data=dev_data,\n output_dir=self.config.output_dir,\n show_running_loss=False,\n args=train_params,\n )\n\n ## backing up the config and create pointer to best model \n with open(os.path.join(self.config.best_model,\"trainer_config.json\"),'w') as mconfig:\n mconfig.write(json.dumps(self.config.__dict__))\n self.config.existing_model = self.config.best_model","def train(self, resume_from_checkpoint: Optional[Union[str, bool]] = None,\n trial: Union[\"optuna.Trial\", Dict[str, Any]] = None, ignore_keys_for_eval: Optional[List[str]] = None, **kwargs):\n\n # memory metrics - must set up as early as possible\n self._memory_tracker.start()\n\n args = self.args\n\n self.is_in_train = True\n\n # do_train is not a reliable argument, as it might not be set and .train() still called, so\n # the following is a workaround:\n if args.fp16_full_eval and not args.do_train:\n self.model = self.model.to(args.device)\n\n if \"model_path\" in kwargs:\n resume_from_checkpoint = kwargs.pop(\"model_path\")\n if len(kwargs) > 0:\n raise TypeError(f\"train() received got unexpected keyword arguments: {', '.join(list(kwargs.keys()))}.\")\n\n # This might change the seed so needs to run first.\n self._hp_search_setup(trial)\n\n # Model re-init\n model_reloaded = False\n if self.model_init is not None:\n # Seed must be set before instantiating the model when using model_init.\n set_seed(args.seed)\n self.model = self.call_model_init(trial)\n model_reloaded = True\n\n # Reinitializes optimizer and scheduler\n self.optimizer, self.lr_scheduler = None, None\n\n # Load potential model checkpoint\n if isinstance(resume_from_checkpoint, bool) and resume_from_checkpoint:\n resume_from_checkpoint = get_last_checkpoint(args.output_dir)\n if resume_from_checkpoint is None:\n raise ValueError(f\"No valid checkpoint found in output directory ({args.output_dir})\")\n\n # If model was re-initialized, put it on the right device and update self.model_wrapped\n if model_reloaded:\n if self.place_model_on_device:\n self.model = self.model.to(args.device)\n self.model_wrapped = self.model\n\n # Keeping track whether we can len() on the dataset or not\n train_dataset_is_sized = isinstance(self.train_dataset, collections.abc.Sized)\n\n # Data loader and number of training steps\n train_dataloader = self.get_train_dataloader()\n\n # Setting up training control variables:\n # number of training epochs: num_train_epochs\n # number of training steps per epoch: num_update_steps_per_epoch\n # total number of training steps to execute: max_steps\n if train_dataset_is_sized:\n num_update_steps_per_epoch = len(train_dataloader) // args.gradient_accumulation_steps\n num_update_steps_per_epoch = max(num_update_steps_per_epoch, 1)\n if args.max_steps > 0:\n max_steps = args.max_steps\n num_train_epochs = args.max_steps // num_update_steps_per_epoch + int(\n args.max_steps % num_update_steps_per_epoch > 0\n )\n else:\n max_steps = math.ceil(args.num_train_epochs * num_update_steps_per_epoch)\n num_train_epochs = math.ceil(args.num_train_epochs)\n else:\n # see __init__. max_steps is set when the dataset has no __len__\n max_steps = args.max_steps\n num_train_epochs = int(args.num_train_epochs)\n num_update_steps_per_epoch = max_steps\n\n self.create_optimizer_and_scheduler(num_training_steps=max_steps)\n\n self.state = TrainerState()\n self.state.is_hyper_param_search = trial is not None\n\n model = self._wrap_model(self.model_wrapped)\n\n # for the rest of this function `model` is the outside model, whether it was wrapped or not\n if model is not self.model:\n self.model_wrapped = model\n\n # Check if saved optimizer or scheduler states exist\n self._load_optimizer_and_scheduler(resume_from_checkpoint)\n\n # Train!\n world_size = 1 # number of processes in parallel\n\n total_train_batch_size = args.train_batch_size * args.gradient_accumulation_steps * world_size\n num_examples = (self.num_examples(train_dataloader) if train_dataset_is_sized else total_train_batch_size * args.max_steps)\n\n logger.info(\"***** Running training *****\")\n logger.info(f\" Num examples = {num_examples}\")\n logger.info(f\" Num Epochs = {num_train_epochs}\")\n logger.info(f\" Instantaneous batch size per device = {args.per_device_train_batch_size}\")\n logger.info(f\" Total train batch size (w. parallel, distributed & accumulation) = {total_train_batch_size}\")\n logger.info(f\" Gradient Accumulation steps = {args.gradient_accumulation_steps}\")\n logger.info(f\" Total optimization steps = {max_steps}\")\n\n self.state.epoch = 0\n start_time = time.time()\n epochs_trained = 0\n steps_trained_in_current_epoch = 0\n steps_trained_progress_bar = None\n\n # Check if continuing training from a checkpoint\n if resume_from_checkpoint is not None and os.path.isfile(os.path.join(resume_from_checkpoint, \"trainer_state.json\")):\n self.state = TrainerState.load_from_json(os.path.join(resume_from_checkpoint, \"trainer_state.json\"))\n epochs_trained = self.state.global_step // num_update_steps_per_epoch\n if not args.ignore_data_skip:\n steps_trained_in_current_epoch = self.state.global_step % (num_update_steps_per_epoch)\n steps_trained_in_current_epoch *= args.gradient_accumulation_steps\n else:\n steps_trained_in_current_epoch = 0\n\n logger.info(\" Continuing training from checkpoint, will skip to saved global_step\")\n logger.info(f\" Continuing training from epoch {epochs_trained}\")\n logger.info(f\" Continuing training from global step {self.state.global_step}\")\n if not args.ignore_data_skip:\n logger.info(\n f\" Will skip the first {epochs_trained} epochs then the first {steps_trained_in_current_epoch} \"\n \"batches in the first epoch. If this takes a lot of time, you can add the `--ignore_data_skip` \"\n \"flag to your launch command, but you will resume the training on data already seen by your model.\"\n )\n if self.is_local_process_zero() and not args.disable_tqdm:\n steps_trained_progress_bar = tqdm(total=steps_trained_in_current_epoch)\n steps_trained_progress_bar.set_description(\"Skipping the first batches\")\n\n # Update the references\n self.callback_handler.model = self.model\n self.callback_handler.optimizer = self.optimizer\n self.callback_handler.lr_scheduler = self.lr_scheduler\n self.callback_handler.train_dataloader = train_dataloader\n self.state.trial_name = self.hp_name(trial) if self.hp_name is not None else None\n self.state.trial_params = hp_params(trial) if trial is not None else None\n # This should be the same if the state has been saved but in case the training arguments changed, it's safer\n # to set this after the load.\n self.state.max_steps = max_steps\n self.state.num_train_epochs = num_train_epochs\n self.state.is_local_process_zero = self.is_local_process_zero()\n self.state.is_world_process_zero = self.is_world_process_zero()\n\n # tr_loss is a tensor to avoid synchronization of TPUs through .item()\n tr_loss = torch.tensor(0.0).to(args.device)\n # _total_loss_scalar is updated everytime .item() has to be called on tr_loss and stores the sum of all losses\n self._total_loss_scalar = 0.0\n self._globalstep_last_logged = self.state.global_step\n model.zero_grad()\n\n self.control = self.callback_handler.on_train_begin(args, self.state, self.control)\n\n # Skip the first epochs_trained epochs to get the random state of the dataloader at the right point.\n if not args.ignore_data_skip:\n for epoch in range(epochs_trained):\n # We just need to begin an iteration to create the randomization of the sampler.\n for _ in train_dataloader:\n break\n\n for epoch in range(epochs_trained, num_train_epochs):\n epoch_iterator = train_dataloader\n\n # Reset the past mems state at the beginning of each epoch if necessary.\n if args.past_index >= 0:\n self._past = None\n\n steps_in_epoch = (len(epoch_iterator) if train_dataset_is_sized else args.max_steps * args.gradient_accumulation_steps)\n self.control = self.callback_handler.on_epoch_begin(args, self.state, self.control)\n\n for step, inputs in enumerate(epoch_iterator):\n # Skip past any already trained steps if resuming training\n if steps_trained_in_current_epoch > 0:\n steps_trained_in_current_epoch -= 1\n if steps_trained_progress_bar is not None:\n steps_trained_progress_bar.update(1)\n if steps_trained_in_current_epoch == 0:\n self._load_rng_state(resume_from_checkpoint)\n continue\n\n elif steps_trained_progress_bar is not None:\n steps_trained_progress_bar.close()\n steps_trained_progress_bar = None\n\n if step % args.gradient_accumulation_steps == 0:\n self.control = self.callback_handler.on_step_begin(args, self.state, self.control)\n\n tr_loss += self.custom_training_step(model, inputs)\n\n self.current_flos += float(self.floating_point_ops(inputs))\n\n # Optimizer step for deepspeed must be called on every step regardless of the value of gradient_accumulation_steps\n if (step + 1) % args.gradient_accumulation_steps == 0 or (\n # last step in epoch but step is always smaller than gradient_accumulation_steps\n steps_in_epoch <= args.gradient_accumulation_steps\n and (step + 1) == steps_in_epoch\n ):\n # Gradient clipping\n if args.max_grad_norm is not None and args.max_grad_norm > 0:\n torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)\n\n # Optimizer step\n optimizer_was_run = True\n self.optimizer.step()\n\n if optimizer_was_run:\n self.lr_scheduler.step()\n\n model.zero_grad()\n\n self.state.global_step += 1\n self.state.epoch = epoch + (step + 1) / steps_in_epoch\n self.control = self.callback_handler.on_step_end(args, self.state, self.control)\n\n self._maybe_log_save_evaluate(tr_loss, model, trial, epoch, ignore_keys_for_eval)\n\n if self.control.should_epoch_stop or self.control.should_training_stop:\n break\n\n self.control = self.callback_handler.on_epoch_end(args, self.state, self.control)\n self._maybe_log_save_evaluate(tr_loss, model, trial, epoch, ignore_keys_for_eval)\n\n if self.control.should_training_stop:\n break\n\n if args.past_index and hasattr(self, \"_past\"):\n # Clean the state at the end of training\n delattr(self, \"_past\")\n\n logger.info(\"\\n\\nTraining completed. Do not forget to share your model on huggingface.co/models =)\\n\\n\")\n if args.load_best_model_at_end and self.state.best_model_checkpoint is not None:\n logger.info(f\"Loading best model from {self.state.best_model_checkpoint} (score: {self.state.best_metric}).\")\n\n # We load the model state dict on the CPU to avoid an OOM error.\n state_dict = torch.load(os.path.join(self.state.best_model_checkpoint, WEIGHTS_NAME), map_location=\"cpu\")\n # If the model is on the GPU, it still works!\n self.model.load_state_dict(state_dict)\n\n metrics = speed_metrics(\"train\", start_time, self.state.max_steps)\n self.store_flos()\n metrics[\"total_flos\"] = self.state.total_flos\n self.log(metrics)\n\n self.control = self.callback_handler.on_train_end(args, self.state, self.control)\n # add remaining tr_loss\n self._total_loss_scalar += tr_loss.item()\n\n self.is_in_train = False\n\n self._memory_tracker.stop_and_update_metrics(metrics)\n\n return TrainOutput(self.state.global_step, self._total_loss_scalar / self.state.global_step, metrics)","def run(self):\n # Get the checkpoint file\n print('loading checkpoint file ...')\n cp = torch.load(self.cfg.work_dir + '/latest.pth')\n print('done')\n\n print('loading state dictionary ...')\n # Initialize network first as separate modules so we can access WFCOS\n backbone = build_backbone(self.cfg.model.backbone).cuda()\n neck = build_neck(self.cfg.model.neck).cuda()\n head = build_head(self.cfg.model.bbox_head).cuda()\n\n # Load the state dicts\n backbone_state = OrderedDict()\n neck_state = OrderedDict()\n head_state = OrderedDict()\n\n for key in cp['state_dict'].keys():\n if 'backbone' in key:\n backbone_state[key.split('.', 1)[1]] = cp['state_dict'][key]\n elif 'neck' in key:\n neck_state[key.split('.', 1)[1]] = cp['state_dict'][key]\n elif 'bbox_head' in key:\n head_state[key.split('.', 1)[1]] = cp['state_dict'][key]\n\n backbone.load_state_dict(backbone_state)\n neck.load_state_dict(neck_state)\n head.load_state_dict(head_state)\n\n # Set to eval mode\n backbone.eval()\n neck.eval()\n head.eval()\n\n print('done')\n\n print('starting inference validation run ...')\n for i, (img, cls) in enumerate(self.loader):\n out = backbone(img)\n out = neck(out)\n out = head(out)\n\n img_metas = [{'img_shape': (640, 800),\n 'scale_factor': 1}]\n bboxes = head.get_bboxes(out[0], out[1], out[2], img_metas,\n self.cfg.test_cfg)\n pass\n print('done')","def _load_checkpoint(cls, model: DeviceAwareModule, checkpoint_path: Path,\n key_in_state_dict: str, use_gpu: bool) -> int:\n logging.info(f\"Loading checkpoint {checkpoint_path}\")\n checkpoint = ModelAndInfo.read_checkpoint(checkpoint_path, use_gpu)\n\n try:\n state_dict = checkpoint[key_in_state_dict]\n except KeyError:\n logging.error(f\"Key {key_in_state_dict} not found in checkpoint\")\n return False\n\n if isinstance(model, torch.nn.DataParallel):\n result = model.module.load_state_dict(state_dict, strict=False)\n else:\n result = model.load_state_dict(state_dict, strict=False)\n\n if result.missing_keys:\n logging.warning(f\"Missing keys in model checkpoint: {result.missing_keys}\")\n if result.unexpected_keys:\n logging.warning(f\"Unexpected keys in model checkpoint: {result.unexpected_keys}\")\n\n return checkpoint[ModelAndInfo.EPOCH_KEY]","def try_and_init_from(self, path):\n log.info(\"Loading weights from foreign checkpoint {}\".format(path))\n if not os.path.exists(path):\n raise ValueError(\"Checkpoint {} does not exist\".format(path))\n\n chkpt = th.load(path, map_location=th.device(\"cpu\"))\n if \"model\" not in chkpt.keys() or chkpt[\"model\"] is None:\n raise ValueError(\"{} has no model saved\".format(path))\n\n mdl = chkpt[\"model\"]\n for n, p in self.model.named_parameters():\n if n in mdl:\n p2 = mdl[n]\n if p2.shape != p.shape:\n log.warning(\"Parameter {} ignored, checkpoint size does not match: {}, should be {}\".format(n, p2.shape, p.shape))\n continue\n log.debug(\"Parameter {} copied\".format(n))\n p.data.copy_(p2)\n else:\n log.warning(\"Parameter {} ignored, not found in source checkpoint.\".format(n))\n\n log.info(\"Weights loaded from foreign checkpoint {}\".format(path))","def initialize_model_from_cfg(args, gpu_id=0):\n model = model_builder.Generalized_RCNN()\n model.eval()\n\n if args.cuda:\n model.cuda()\n\n if args.load_ckpt:\n load_name = args.load_ckpt\n logger.info(\"loading checkpoint %s\", load_name)\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\n net_utils.load_ckpt(model, checkpoint['model'])\n\n if args.load_detectron:\n logger.info(\"loading detectron weights %s\", args.load_detectron)\n load_caffe2_detectron_weights(model, args.load_detectron)\n\n model = mynn.DataParallel(model, cpu_keywords=['im_info', 'roidb'], minibatch=True)\n\n return model","def load_model(self):\n if self.ckpt_flag:\n LOG('Skip Loading Pre-trained Model......')\n else:\n if self.params.pre_trained_from is not None and os.path.exists(self.params.pre_trained_from):\n try:\n LOG('Loading Pre-trained Model at %s' % self.params.pre_trained_from)\n pretrain = torch.load(self.params.pre_trained_from)\n self.network.load_state_dict(pretrain)\n LOG('Pre-trained Model Loaded!')\n except:\n WARNING('Cannot load pre-trained model. Start training......')\n else:\n WARNING('Pre-trained model do not exits. Start training......')","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def train_model(\n checkpoint: int,\n checkpoint_step: int,\n data_loader: torch.utils.data.DataLoader,\n device: torch.device,\n epoch: int,\n experiment: str,\n max_norm: float,\n model: lmp.model.BaseRNNModel,\n optimizer: Union[\n torch.optim.SGD,\n torch.optim.Adam,\n ],\n vocab_size: int\n):\n # Set experiment output folder.\n file_dir = f'{lmp.path.DATA_PATH}/{experiment}'\n\n if not os.path.exists(file_dir):\n os.makedirs(file_dir)\n\n # Set experiment log folder.\n writer = torch.utils.tensorboard.SummaryWriter(\n f'{lmp.path.DATA_PATH}/log/{experiment}'\n )\n\n # Define objective function.\n criterion = torch.nn.CrossEntropyLoss()\n\n # Step = number of updates.\n # Every update must increment `step`.\n step = 0\n\n # Set model to train mode.\n model.train()\n\n # Clean up gradient in model parameters.\n model.zero_grad()\n\n # Initialize total loss.\n total_loss = 0.0\n\n for cur_epoch in range(epoch):\n\n epoch_iterator = tqdm(\n data_loader,\n desc=f'epoch: {cur_epoch}, loss: {0:.6f}'\n )\n\n for x, y in epoch_iterator:\n # Increment step for each update.\n step += 1\n\n # Continue training from previous checkpoint step.\n if step < checkpoint:\n continue\n\n # Put tensors on to specified device (CPU or GPU). Reshape `y` into\n # shape (B x S) for cross-entropy.\n # x.size = (B, S)\n # y.size = (B x S)\n x = x.to(device)\n y = y.reshape(-1).to(device)\n\n # Forward pass.\n # pred_y_logits.size = (B, S, V)\n pred_y_logits = model(x)\n\n # Reshape `pred_y_logits` into shape (B x S, V) for cross-entropy.\n pred_y_logits = pred_y_logits.reshape(-1, vocab_size)\n\n # Perform cross-entropy.\n loss = criterion(pred_y_logits, y)\n\n # Calculate total loss.\n total_loss += loss.item()\n\n # Log loss.\n epoch_iterator.set_description(\n f'epoch: {cur_epoch}, loss: {loss.item():.6f}'\n )\n\n # Backward pass.\n loss.backward()\n\n # Perform gradient clipping to avoid gradient explosion.\n torch.nn.utils.clip_grad_norm_(\n model.parameters(),\n max_norm\n )\n\n # Gradient descent.\n optimizer.step()\n\n # `torch` required manually clean up gradient.\n optimizer.zero_grad()\n\n # Save checkpoint for each `checkpoint_step`.\n if step % checkpoint_step == 0:\n torch.save(\n model.state_dict(),\n os.path.join(\n file_dir,\n f'model-{step}.pt'\n )\n )\n torch.save(\n optimizer.state_dict(),\n os.path.join(\n file_dir,\n f'optimizer-{step}.pt'\n )\n )\n # Log average loss.\n writer.add_scalar(\n f'{experiment}/loss',\n total_loss / checkpoint_step,\n step\n )\n total_loss = 0.0\n\n # Save last checkpoint.\n torch.save(\n model.state_dict(),\n os.path.join(\n file_dir,\n f'model-{step}.pt'\n )\n )\n torch.save(\n optimizer.state_dict(),\n os.path.join(\n file_dir,\n f'optimizer-{step}.pt'\n )\n )","def train(self, config, **kwargs):\n\n config_parameters = utils.parse_config_or_kwargs(config, **kwargs)\n outputdir = Path(\n config_parameters['outputpath'], config_parameters['model'],\n \"{}_{}\".format(\n datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%m'),\n uuid.uuid1().hex[:8]))\n # Early init because of creating dir\n checkpoint_handler = ModelCheckpoint(\n outputdir,\n 'run',\n n_saved=1,\n require_empty=False,\n create_dir=True,\n score_function=lambda engine: -engine.state.metrics['Loss'],\n save_as_state_dict=False,\n score_name='loss')\n logger = utils.getfile_outlogger(Path(outputdir, 'train.log'))\n logger.info(\"Storing files in {}\".format(outputdir))\n # utils.pprint_dict\n utils.pprint_dict(config_parameters, logger.info)\n logger.info(\"Running on device {}\".format(DEVICE))\n labels_df = pd.read_csv(config_parameters['trainlabel'], sep=' ')\n labels_df['encoded'], encoder = utils.encode_labels(\n labels=labels_df['bintype'])\n train_df, cv_df = utils.split_train_cv(labels_df)\n\n transform = utils.parse_transforms(config_parameters['transforms'])\n utils.pprint_dict({'Classes': encoder.classes_},\n logger.info,\n formatter='pretty')\n utils.pprint_dict(transform, logger.info, formatter='pretty')\n if 'sampler' in config_parameters and config_parameters[\n 'sampler'] == 'MinimumOccupancySampler':\n # Asserts that each \"batch\" contains at least one instance\n train_sampler = dataset.MinimumOccupancySampler(\n np.stack(train_df['encoded'].values))\n\n sampling_kwargs = {\"sampler\": train_sampler, \"shuffle\": False}\n elif 'shuffle' in config_parameters and config_parameters['shuffle']:\n sampling_kwargs = {\"shuffle\": True}\n else:\n sampling_kwargs = {\"shuffle\": False}\n\n logger.info(\"Using Sampler {}\".format(sampling_kwargs))\n\n colname = config_parameters.get('colname', ('filename', 'encoded')) #\n trainloader = dataset.getdataloader(\n train_df,\n config_parameters['traindata'],\n transform=transform,\n batch_size=config_parameters['batch_size'],\n colname=colname, # For other datasets with different key names\n num_workers=config_parameters['num_workers'],\n **sampling_kwargs)\n cvdataloader = dataset.getdataloader(\n cv_df,\n config_parameters['traindata'],\n transform=None,\n shuffle=False,\n colname=colname, # For other datasets with different key names\n batch_size=config_parameters['batch_size'],\n num_workers=config_parameters['num_workers'])\n if 'pretrained' in config_parameters and config_parameters[\n 'pretrained'] is not None:\n model = models.load_pretrained(config_parameters['pretrained'],\n outputdim=len(encoder.classes_))\n else:\n model = getattr(models, config_parameters['model'],\n 'LightCNN')(inputdim=trainloader.dataset.datadim,\n outputdim=len(encoder.classes_),\n **config_parameters['model_args'])\n\n if config_parameters['optimizer'] == 'AdaBound':\n try:\n import adabound\n optimizer = adabound.AdaBound(\n model.parameters(), **config_parameters['optimizer_args'])\n except ImportError:\n logger.info(\n \"Adabound package not found, install via pip install adabound. Using Adam instead\"\n )\n config_parameters['optimizer'] = 'Adam'\n config_parameters['optimizer_args'] = {\n } # Default adam is adabount not found\n else:\n optimizer = getattr(\n torch.optim,\n config_parameters['optimizer'],\n )(model.parameters(), **config_parameters['optimizer_args'])\n\n utils.pprint_dict(optimizer, logger.info, formatter='pretty')\n utils.pprint_dict(model, logger.info, formatter='pretty')\n if DEVICE.type != 'cpu' and torch.cuda.device_count() > 1:\n logger.info(\"Using {} GPUs!\".format(torch.cuda.device_count()))\n model = torch.nn.DataParallel(model)\n criterion = torch.nn.CrossEntropyLoss().to(DEVICE)\n model = model.to(DEVICE)\n\n precision = Precision()\n recall = Recall()\n f1_score = (precision * recall * 2 / (precision + recall)).mean()\n metrics = {\n 'Loss': Loss(criterion),\n 'Precision': precision.mean(),\n 'Recall': recall.mean(),\n 'Accuracy': Accuracy(),\n 'F1': f1_score,\n }\n\n # batch contains 3 elements, X,Y and filename. Filename is only used\n # during evaluation\n def _prep_batch(batch, device=DEVICE, non_blocking=False):\n x, y, _ = batch\n return (convert_tensor(x, device=device,\n non_blocking=non_blocking),\n convert_tensor(y, device=device,\n non_blocking=non_blocking))\n\n train_engine = create_supervised_trainer(model,\n optimizer=optimizer,\n loss_fn=criterion,\n prepare_batch=_prep_batch,\n device=DEVICE)\n inference_engine = create_supervised_evaluator(\n model, metrics=metrics, prepare_batch=_prep_batch, device=DEVICE)\n\n RunningAverage(output_transform=lambda x: x).attach(\n train_engine, 'run_loss') # Showing progressbar during training\n pbar = ProgressBar(persist=False)\n pbar.attach(train_engine, ['run_loss'])\n scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,\n patience=3,\n factor=0.1)\n\n @inference_engine.on(Events.COMPLETED)\n def update_reduce_on_plateau(engine):\n val_loss = engine.state.metrics['Loss']\n if 'ReduceLROnPlateau' == scheduler.__class__.__name__:\n scheduler.step(val_loss)\n else:\n scheduler.step()\n\n early_stop_handler = EarlyStopping(\n patience=5,\n score_function=lambda engine: -engine.state.metrics['Loss'],\n trainer=train_engine)\n inference_engine.add_event_handler(Events.EPOCH_COMPLETED,\n early_stop_handler)\n inference_engine.add_event_handler(Events.EPOCH_COMPLETED,\n checkpoint_handler, {\n 'model': model,\n 'encoder': encoder,\n 'config': config_parameters,\n })\n\n @train_engine.on(Events.EPOCH_COMPLETED)\n def compute_validation_metrics(engine):\n inference_engine.run(cvdataloader)\n results = inference_engine.state.metrics\n output_str_list = [\n \"Validation Results - Epoch : {:<5}\".format(engine.state.epoch)\n ]\n for metric in metrics:\n output_str_list.append(\"{} {:<5.3f}\".format(\n metric, results[metric]))\n logger.info(\" \".join(output_str_list))\n pbar.n = pbar.last_print_n = 0\n\n train_engine.run(trainloader, max_epochs=config_parameters['epochs'])\n return outputdir","def __init__(self, model: str, **kwargs):\n super().__init__(model=model, **kwargs)\n self.path = model\n self.model = get_zennet()\n\n model_pth_path = osp.join(self.path, ModelFile.TORCH_MODEL_FILE)\n\n checkpoint = torch.load(model_pth_path, map_location='cpu')\n if 'state_dict' in checkpoint:\n state_dict = checkpoint['state_dict']\n else:\n state_dict = checkpoint\n\n self.model.load_state_dict(state_dict, strict=True)\n logger.info('load model done')","def train_model(config, environ, train_data, test_data, trainval_data=None):\n np.random.seed(0)\n if not hasattr(config, \"seed\"):\n tf.set_random_seed(1234)\n log.info(\"Setting tensorflow random seed={:d}\".format(1234))\n else:\n log.info(\"Setting tensorflow random seed={:d}\".format(config.seed))\n tf.set_random_seed(config.seed)\n if environ.verbose:\n verbose_level = 0\n else:\n verbose_level = 2\n\n if trainval_data is None:\n trainval_data = train_data\n\n log.info(\"Environment: {}\".format(environ.__dict__))\n log.info(\"Config: {}\".format(config.__dict__))\n\n save_folder = os.path.join(environ.save_folder, environ.exp_id)\n logs_folder = os.path.join(environ.logs_folder, environ.exp_id)\n with log.verbose_level(verbose_level):\n exp_logger = ExperimentLogger(logs_folder)\n\n if not hasattr(config, \"seed\"):\n data_seed = 0\n else:\n data_seed = config.seed\n\n # Gets data iterators.\n train_iter = get_iter(\n train_data,\n batch_size=config.batch_size,\n shuffle=True,\n cycle=True,\n prefetch=config.prefetch,\n seed=data_seed,\n num_worker=25,\n queue_size=500)\n trainval_iter = get_iter(\n train_data,\n batch_size=config.batch_size,\n shuffle=True,\n cycle=True,\n prefetch=config.prefetch,\n num_worker=10,\n queue_size=200)\n test_iter = get_iter(\n test_data,\n batch_size=config.batch_size,\n shuffle=False,\n cycle=False,\n prefetch=config.prefetch,\n num_worker=10,\n queue_size=200)\n\n # Builds models.\n log.info(\"Building models\")\n with tf.name_scope(\"Train\"):\n with tf.variable_scope(\"Model\", reuse=None):\n with tf.device(environ.device):\n if config.model.startswith(\"resnet\"):\n m = ResNetModel(config, is_training=True)\n else:\n m = CNNModel(config, is_training=True)\n\n with tf.name_scope(\"Valid\"):\n with tf.variable_scope(\"Model\", reuse=True):\n with tf.device(environ.device):\n if config.model.startswith(\"resnet\"):\n mvalid = ResNetModel(config, is_training=False)\n else:\n mvalid = CNNModel(config, is_training=False)\n\n # Initializes variables.\n with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:\n saver = tf.train.Saver()\n sess.run(tf.global_variables_initializer())\n\n def train_step():\n \"\"\"Train step.\"\"\"\n batch = train_iter.next()\n feed_data = {m.input: batch[\"img\"], m.label: batch[\"label\"]}\n cost, ce, _ = sess.run([m.cost, m.cross_ent, m.train_op],\n feed_dict=feed_data)\n return ce\n\n def evaluate(data_iter, nbatches):\n \"\"\"Runs evaluation.\"\"\"\n num_correct = 0.0\n count = 0\n if nbatches == -1:\n iter_ = data_iter\n else:\n iter_ = range(nbatches)\n\n for bb in iter_:\n if nbatches == -1:\n batch = bb\n else:\n batch = data_iter.next()\n feed_data = {mvalid.input: batch[\"img\"]}\n y = sess.run(mvalid.output, feed_dict=feed_data)\n pred_label = np.argmax(y, axis=1)\n num_correct += np.sum(\n np.equal(pred_label, batch[\"label\"]).astype(float))\n count += pred_label.size\n acc = (num_correct / count)\n return acc\n\n def save():\n \"\"\"Snapshots a model.\"\"\"\n if not os.path.isdir(save_folder):\n os.makedirs(save_folder)\n config_file = os.path.join(save_folder, \"conf.json\")\n environ_file = os.path.join(save_folder, \"env.json\")\n with open(config_file, \"w\") as f:\n f.write(config.to_json())\n with open(environ_file, \"w\") as f:\n f.write(environ.to_json())\n log.info(\"Saving to {}\".format(save_folder))\n saver.save(\n sess,\n os.path.join(save_folder, \"model.ckpt\"),\n global_step=m.global_step)\n\n def train():\n \"\"\"Train loop.\"\"\"\n lr = config.base_learn_rate\n lr_decay_steps = config.lr_decay_steps\n max_train_iter = config.max_train_iter\n m.assign_lr(sess, lr)\n\n if environ.verbose:\n loop = range(max_train_iter)\n else:\n loop = pb.get(max_train_iter)\n\n for niter in loop:\n # decrease learning rate\n if len(lr_decay_steps) > 0:\n if (niter + 1) == lr_decay_steps[0]:\n lr *= 0.1\n m.assign_lr(sess, lr)\n lr_decay_steps.pop(0)\n ce = train_step()\n if (niter + 1) % config.disp_iter == 0 or niter == 0:\n exp_logger.log_train_ce(niter, ce)\n if (niter + 1) % config.valid_iter == 0 or niter == 0:\n acc = evaluate(trainval_iter, 10)\n exp_logger.log_train_acc(niter, acc)\n test_iter.reset()\n acc = evaluate(test_iter, -1)\n log.info(\"Experment ID {}\".format(environ.exp_id))\n exp_logger.log_valid_acc(niter, acc)\n if (niter + 1) % config.save_iter == 0:\n save()\n test_iter.reset()\n acc = evaluate(test_iter, -1)\n return acc\n\n acc = train()\n return acc","def save_model(self, checkpoint_path, epoch):\n self.saver.save(self.sess, checkpoint_path, global_step = epoch)","def load_checkpoint(checkpoint_path, model, optimizer=None):\n if not os.path.exists(checkpoint_path):\n raise IOError(f\"Checkpoint '{checkpoint_path}' does not exist\")\n\n state = torch.load(checkpoint_path)\n try:\n model.load_state_dict(state['model_state_dict'])\n except BaseException as e:\n print('Failed to do something: ' + str(e))\n\n if optimizer is not None:\n try:\n optimizer.load_state_dict(state['optimizer_state_dict'])\n except Exception as e:\n print(e)\n\n return state"],"string":"[\n \"def load(self, model_path):\\n # TODO: include new params based on ConfigEnum\\n checkpoint = torch.load(model_path)\\n\\n self.image_size = checkpoint['image_size']\\n self.device = checkpoint['device']\\n self.fp16 = checkpoint['fp16']\\n self.accumulate_grad_steps = checkpoint['accumulate_grad_steps']\\n self.experiment_id = checkpoint['experiment_id']\\n self.experiment_tag = checkpoint['experiment_tag']\\n self.seed = checkpoint['seed']\\n self.train_batch_size = checkpoint['train_batch_size']\\n self.valid_batch_size = checkpoint['valid_batch_size']\\n self.test_batch_size = checkpoint['test_batch_size']\\n self.dataloader_num_workers = checkpoint['dataloader_num_workers']\\n self.train_dataloader_shuffle = checkpoint['train_dataloader_shuffle']\\n self.optimizer_type = checkpoint['optimizer_type']\\n self.optimizer_params = checkpoint['optimizer_params']\\n self.scheduler_type = checkpoint['scheduler_type']\\n self.scheduler_params = checkpoint['scheduler_params']\\n self.step_scheduler_after = checkpoint['step_scheduler_after']\\n self.step_scheduler_metric = checkpoint['step_scheduler_metric']\\n self.compute_train_loss_after = checkpoint['compute_train_loss_after']\\n self.compute_train_metric_after = checkpoint['compute_train_metric_after']\\n self.compute_valid_loss_after = checkpoint['compute_valid_loss_after']\\n self.compute_valid_metric_after = checkpoint['compute_valid_metric_after']\\n self.training_stopping_criteria = checkpoint['training_stopping_criteria']\\n self.stopping_criteria_params = checkpoint['stopping_criteria_params']\\n self.max_epoch = checkpoint['max_epoch']\\n self.train_on_all_data = checkpoint['train_on_all_data']\\n self.validate_after = checkpoint['validate_after']\\n self.validation_steps = checkpoint['validation_steps']\\n self.run_lr_range_test= checkpoint['run_lr_range_test']\\n self.sleep_in_epochs = checkpoint['sleep_in_epochs']\\n self.sleep_time = checkpoint['sleep_time']\\n self.checkpoint_epochs = checkpoint['checkpoint_epochs']\\n\\n self._best_score = checkpoint['_best_score']\\n self._current_score = checkpoint['_current_score']\\n self._counter = checkpoint['_counter']\\n self.metrics = checkpoint['metrics']\\n self.current_epoch = checkpoint['current_epoch']\\n self.current_train_batch = checkpoint['current_train_batch']\\n self.current_valid_batch = checkpoint['current_valid_batch']\\n self.num_train_samples = checkpoint['num_train_samples']\\n self.num_train_iterations = checkpoint['num_train_iterations']\\n self.checkpoint_snapshot = checkpoint['checkpoint_snapshot'] \\n\\n # initialize optimizer, scheduler, and gradient scaler\\n self.configure_optimizers()\\n self.configure_schedulers()\\n \\n if self.fp16:\\n self.scaler = torch.cuda.amp.GradScaler()\\n\\n if self.model:\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.model.to(self.device)\\n\\n if self.optimizer:\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n if self.scheduler:\\n self.scheduler.load_state_dict(checkpoint['scheduler'])\\n\\n #if self.scaler:\\n # self.scaler.load_state_dict(checkpoint['scaler'])\",\n \"def load_model(self, checkpoint):\\n print(f'Load parameters from {checkpoint}')\\n epoch = re.match(r\\\"[0-9]*\\\", os.path.basename(checkpoint)).group(0)\\n self.epoch_i = int(epoch)\\n self.model.load_state_dict(torch.load(checkpoint))\",\n \"def save_checkpoint(self, model_path=None):\\n # TODO: include new params based on ConfigEnum\\n if not os.path.isdir(path_checkpoints_dir):\\n os.mkdir(path_checkpoints_dir)\\n if model_path is None:\\n model_path = os.path.join(path_checkpoints_dir, f\\\"{self.experiment_id}.pth\\\")\\n print(f\\\"saved the model at {model_path}\\\") \\n model_state_dict = self.model.state_dict()\\n if self.optimizer is not None:\\n opt_state_dict = self.optimizer.state_dict()\\n else:\\n opt_state_dict = None\\n if self.scheduler is not None:\\n sch_state_dict = self.scheduler.state_dict()\\n else:\\n sch_state_dict = None\\n \\n if self.scaler is not None:\\n amp_grad_scaler = self.scaler.state_dict()\\n else:\\n amp_grad_scaler = None\\n\\n model_dict = {}\\n model_dict[\\\"state_dict\\\"] = model_state_dict\\n model_dict[\\\"optimizer\\\"] = opt_state_dict\\n model_dict[\\\"scheduler\\\"] = sch_state_dict\\n model_dict['scaler'] = amp_grad_scaler\\n model_dict['image_size'] = self.image_size\\n model_dict['device'] = self.device\\n model_dict['fp16'] = self.fp16\\n model_dict['accumulate_grad_steps'] = self.accumulate_grad_steps\\n\\n model_dict['experiment_id'] = self.experiment_id\\n model_dict['experiment_tag'] = self.experiment_tag\\n\\n model_dict['seed'] = self.seed\\n\\n model_dict['train_batch_size'] = self.train_batch_size\\n model_dict['valid_batch_size'] = self.valid_batch_size\\n model_dict['test_batch_size'] = self.test_batch_size\\n model_dict['dataloader_num_workers'] = self.dataloader_num_workers\\n model_dict['train_dataloader_shuffle'] = self.train_dataloader_shuffle\\n\\n model_dict['optimizer_type'] = self.optimizer_type\\n model_dict['optimizer_params'] = self.optimizer_params\\n\\n model_dict['scheduler_type'] = self.scheduler_type\\n model_dict['scheduler_params'] = self.scheduler_params\\n model_dict['step_scheduler_after'] = self.step_scheduler_after\\n model_dict['step_scheduler_metric'] = self.step_scheduler_metric\\n\\n model_dict['compute_train_loss_after'] = self.compute_train_loss_after\\n model_dict['compute_train_metric_after'] = self.compute_train_metric_after\\n model_dict['compute_valid_loss_after'] = self.compute_valid_loss_after\\n model_dict['compute_valid_metric_after'] = self.compute_valid_metric_after\\n\\n model_dict['training_stopping_criteria'] = self.training_stopping_criteria\\n model_dict['stopping_criteria_params'] = self.stopping_criteria_params\\n model_dict['max_epoch'] = self.max_epoch\\n model_dict['train_on_all_data'] = self.train_on_all_data\\n model_dict['validate_after'] = self.validate_after\\n model_dict['validation_steps'] = self.validation_steps\\n model_dict['run_lr_range_test'] = self.run_lr_range_test\\n model_dict['sleep_in_epochs'] = self.sleep_in_epochs\\n model_dict['sleep_time'] = self.sleep_time\\n model_dict['checkpoint_epochs'] = self.checkpoint_epochs\\n\\n model_dict['_best_score'] = self._best_score\\n model_dict['_current_score'] = self._current_score\\n model_dict['_counter'] = self._counter\\n\\n model_dict['metrics'] = self.metrics\\n model_dict['current_epoch'] = self.current_epoch\\n model_dict['current_train_batch'] = self.current_train_batch\\n model_dict['current_valid_batch'] = self.current_valid_batch\\n\\n model_dict['num_train_samples'] = self.num_train_samples\\n model_dict['num_train_iterations'] = self.num_train_iterations\\n model_dict['checkpoint_snapshot'] = self.checkpoint_snapshot \\n torch.save(model_dict, model_path)\",\n \"def create_checkpoint(model_config, path):\\n model = models.VisionTransformer(num_classes=1, **model_config)\\n variables = model.init(\\n jax.random.PRNGKey(0),\\n jnp.ones([1, 16, 16, 3], jnp.float32),\\n train=False,\\n )\\n _save(variables['params'], path)\",\n \"def init_model(config, program, exe):\\n checkpoints = config['Global'].get('checkpoints')\\n if checkpoints:\\n if os.path.exists(checkpoints + '.pdparams'):\\n path = checkpoints\\n fluid.load(program, path, exe)\\n logger.info(\\\"Finish initing model from {}\\\".format(path))\\n else:\\n raise ValueError(\\\"Model checkpoints {} does not exists,\\\"\\n \\\"check if you lost the file prefix.\\\".format(\\n checkpoints + '.pdparams'))\\n else:\\n pretrain_weights = config['Global'].get('pretrain_weights')\\n if pretrain_weights:\\n path = pretrain_weights\\n load_params(exe, program, path)\\n logger.info(\\\"Finish initing model from {}\\\".format(path))\",\n \"def load_model(self, ckpt_fn):\\n checkpoint = torch.load(ckpt_fn)\\n self.net_.load_state_dict(checkpoint[\\\"model\\\"])\\n self.optimizer_.load_state_dict(checkpoint[\\\"optimizer\\\"])\\n self.epoch_ = checkpoint[\\\"epoch\\\"]\\n self.global_step_ = checkpoint[\\\"global_step\\\"]\\n self.model_samples_ = deque(checkpoint[\\\"model_samples\\\"])\\n self.sampler.load_state_dict(checkpoint[\\\"sampler_state\\\"])\\n self.ais_loss.load_state_dict(checkpoint[\\\"ais_state\\\"])\\n self.replay_prob = checkpoint[\\\"replay_prob\\\"]\\n self.max_replay = checkpoint[\\\"max_replay\\\"]\",\n \"def load_checkpoint(path):\\n\\n # Get the model name\\n model_name = path.split('-')[0]\\n assert (model_name in ['vgg16', 'resnet50'\\n ]), \\\"Path must have the correct model name\\\"\\n\\n # Load in checkpoint\\n checkpoint = torch.load(path)\\n\\n if model_name == 'vgg16':\\n model = models.vgg16(pretrained=True)\\n # Make sure to set parameters as not trainable\\n for param in model.parameters():\\n param.requires_grad = False\\n model.classifier = checkpoint['classifier']\\n\\n elif model_name == 'resnet50':\\n model = models.resnet50(pretrained=True)\\n # Make sure to set parameters as not trainable\\n for param in model.parameters():\\n param.requires_grad = False\\n model.fc = checkpoint['fc']\\n\\n # Load in the state dict\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n total_params = sum(p.numel() for p in model.parameters())\\n print(f'{total_params:,} total parameters.')\\n total_trainable_params = sum(\\n p.numel() for p in model.parameters() if p.requires_grad)\\n print(f'{total_trainable_params:,} total gradient parameters.')\\n\\n # Move to gpu\\n if multi_gpu:\\n model = nn.DataParallel(model)\\n\\n if train_on_gpu:\\n model = model.to('cuda')\\n\\n # Model basics\\n model.class_to_idx = checkpoint['class_to_idx']\\n model.idx_to_class = checkpoint['idx_to_class']\\n model.epochs = checkpoint['epochs']\\n\\n # Optimizer\\n optimizer = checkpoint['optimizer']\\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\n\\n return model, optimizer\",\n \"def load(cls, model_path: str, sample_shape: tuple = None,\\n checkpoint: str = None, **kwargs):\",\n \"def maybe_load_model(name, split_num, checkpoint_dir, resume_from_epoch,\\n batch_norm, l1_factor, l2_factor, optimizer):\\n basename = get_basename(name, split_num)\\n model_filename_fmt = get_model_filename_fmt(basename)\\n model_filename = model_filename_fmt.format(epoch=resume_from_epoch)\\n\\n checkpoint_path = os.path.join(checkpoint_dir, model_filename)\\n\\n if resume_from_epoch > 0 and os.path.isfile(checkpoint_path):\\n\\n click.secho(f\\\"Found model checkpoint '{checkpoint_path}'. \\\"\\n f\\\"Resuming from epoch {resume_from_epoch}.\\\", fg='green')\\n\\n model = load_model(checkpoint_path)\\n\\n initial_epoch = resume_from_epoch\\n\\n else:\\n\\n click.secho(f\\\"Could not load model checkpoint '{checkpoint_path}' \\\"\\n \\\"or `resume_from_epoch == 0`. Building new model.\\\",\\n fg='yellow')\\n\\n model = build_model(output_dim=1, batch_norm=batch_norm,\\n kernel_regularizer=l1_l2(l1_factor, l2_factor))\\n # optimizer = Adam(beta_1=0.5)\\n model.compile(loss='binary_crossentropy', optimizer=optimizer,\\n metrics=['accuracy'])\\n\\n initial_epoch = 0\\n\\n return model, initial_epoch\",\n \"def load_model_from_checkpoint(self, path: str):\\n ckpt = torch.load(path, map_location='cpu')\\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\\n self.net_q.head.load_state_dict(ckpt['head'])\\n self.net_ps.load_state_dict(ckpt['net_ps'])\\n self.net_k.load_state_dict(ckpt['net_k'])\\n self.queue.load_state_dict(ckpt['queue'])\\n self.optimizer.load_state_dict(ckpt['optimizer'])\\n if 'scheduler' in ckpt:\\n self.scheduler.load_stae_dict(ckpt['scheduler'])\\n self.move_optimizer_states(self.optimizer, self.local_rank)\",\n \"def load_model(self, ckpt_name=\\\"best_model.pth\\\"):\\n path = \\\"/\\\".join(ckpt_name.split(\\\"/\\\")[:-1])\\n chkpt = torch.load(ckpt_name)\\n self.start_epoch = chkpt['epoch']\\n self.best_metric = chkpt['best_metric']\\n\\n # fix the DataParallel caused problem with keys names\\n if self.multi_gpu_flag:\\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=False)\\n self.net.load_state_dict(new_state_dict)\\n else:\\n try:\\n self.net.load_state_dict(chkpt['state_dict'])\\n except:\\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=True)\\n self.net.load_state_dict(new_state_dict)\\n\\n if self.load_optimizer_state:\\n self.optimizer.load_state_dict(chkpt['optimizer'])\\n logging.info(\\\"******** State loaded ********\\\")\\n\\n training_meta = pickle.load(open(f\\\"{path}/training_meta.pickle.dat\\\", \\\"rb\\\"))\\n for k, v in training_meta.items():\\n if k in self.__class__.__params:\\n setattr(self, k, v)\\n logging.info(\\\"******** Training params loaded ********\\\")\",\n \"def load_checkpoint(ckpt_path):\\n checkpoint = None\\n if ckpt_path:\\n logger.info(\\\"Loading checkpoint from %s\\\" % ckpt_path)\\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\\\"cpu\\\"))\\n\\n if \\\"model\\\" in checkpoint.keys():\\n # This preserves backward-compat for models using customed layernorm\\n def fix_key(s):\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.b_2\\\", r\\\"\\\\1.layer_norm\\\\2.bias\\\", s\\n )\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.a_2\\\", r\\\"\\\\1.layer_norm\\\\2.weight\\\", s\\n )\\n return s\\n\\n checkpoint[\\\"model\\\"] = {\\n fix_key(k): v for k, v in checkpoint[\\\"model\\\"].items()\\n }\\n # Force add_ffnbias to True if bias found in model w_1 keys\\n for key in checkpoint[\\\"model\\\"].keys():\\n if \\\"w_1.bias\\\" in key:\\n checkpoint[\\\"opt\\\"].add_ffnbias = True\\n\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"num_kv\\\"):\\n checkpoint[\\\"opt\\\"].num_kv = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"add_ffnbias\\\"):\\n checkpoint[\\\"opt\\\"].add_ffnbias = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_residual\\\"):\\n checkpoint[\\\"opt\\\"].parallel_residual = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"shared_layer_norm\\\"):\\n checkpoint[\\\"opt\\\"].shared_layer_norm = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"use_ckpting\\\"):\\n checkpoint[\\\"opt\\\"].use_ckpting = []\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"relative_positions_buckets\\\"):\\n checkpoint[\\\"opt\\\"].relative_positions_buckets = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_mode\\\"):\\n checkpoint[\\\"opt\\\"].parallel_mode = \\\"data_parallel\\\"\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"norm_eps\\\"):\\n checkpoint[\\\"opt\\\"].norm_eps = 1e-6\\n\\n # fix v2 compatibility\\n if \\\"generator\\\" in checkpoint.keys() and checkpoint[\\\"generator\\\"]:\\n if \\\"0.weight\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"weight\\\"] = checkpoint[\\\"generator\\\"].pop(\\n \\\"0.weight\\\"\\n )\\n if \\\"0.bias\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"bias\\\"] = checkpoint[\\\"generator\\\"].pop(\\\"0.bias\\\")\\n # end of patch for backward compatibility\\n\\n return checkpoint\",\n \"def load_checkpoint(tag, params, model):\\r\\n file_name = os.path.join(\\\"saved_models\\\", params.path, tag + \\\".pt\\\")\\r\\n logger.info(\\\"Load checkpoint from %s\\\" % file_name)\\r\\n if os.path.exists(file_name):\\r\\n checkpoint = torch.load(file_name, map_location='cpu')\\r\\n params.training_id = checkpoint['training_id']\\r\\n logger.info(checkpoint['training_id'])\\r\\n model.global_step = checkpoint['global_step']\\r\\n model.load_state_dict(checkpoint['model'])\\r\\n for i, optimizer in enumerate(model.optimizers):\\r\\n optimizer.load_state_dict(checkpoint['optimizers'][i])\\r\\n else:\\r\\n raise Exception(\\\"Checkpoint not found.\\\")\",\n \"def load_checkpoint(filepath):\\n checkpoint = torch.load(filepath)\\n \\n arch = checkpoint['arch']\\n if arch == 'vgg':\\n model = models.vgg16(pretrained=True)\\n elif arch == 'densenet':\\n model = models.densenet121(pretrained=True) \\n \\n model.class_to_idx = checkpoint['class_to_idx']\\n model.classifier = checkpoint['classifier']\\n model.classifier.load_sate_dict = checkpoint['classifier_state_dict']\\n model.optimizer = checkpoint['optimizer_state_dict']\\n model.input_size = checkpoint['input_size']\\n model.output_size = checkpoint['output_size']\\n \\n return model\",\n \"def load_model(model, checkpoint_path: str): \\r\\n checkpoint = torch.load(checkpoint_path)\\r\\n model.load_state_dict(checkpoint['model'])\\r\\n epoch = checkpoint['epoch']\\r\\n print('Loaded model from {}, epoch {}'.format(checkpoint_path, epoch))\",\n \"def _init_model(self, checkpoint_path: str) -> None:\\n # load weights\\n logger.info(f\\\"Load weights from the checkpoint {checkpoint_path}\\\")\\n checkpoint = torch.load(checkpoint_path, map_location=torch.device(\\\"cpu\\\"))\\n\\n state_dict = checkpoint[\\\"state_dict\\\"]\\n self.orig_acc = checkpoint[\\\"test_acc\\\"]\\n\\n is_pruned = (\\n next((name for name in state_dict if \\\"mask\\\" in name), None) is not None\\n )\\n\\n if is_pruned:\\n logger.info(\\\"Dummy prunning to load pruned weights\\\")\\n model_utils.dummy_pruning(self.params_all)\\n\\n model_utils.initialize_params(self.model, state_dict)\\n logger.info(\\\"Initialized weights\\\")\\n\\n # check the trained model is pruned\\n\\n if is_pruned:\\n logger.info(\\n \\\"Get masks and remove prunning reparameterization for prepare_qat\\\"\\n )\\n self.mask = model_utils.get_masks(self.model)\\n model_utils.remove_pruning_reparameterization(self.params_all)\",\n \"def load_model(path):\\n if os.path.isfile(path):\\n print(\\\"=> loading checkpoint '{}'\\\".format(path))\\n checkpoint = torch.load(path)\\n\\n # # size of the top layer\\n # N = checkpoint['state_dict']['top_layer.bias'].size()\\n #\\n # # build skeleton of the model\\n # sob = 'sobel.0.weight' in checkpoint['state_dict'].keys()\\n # model = models.__dict__[checkpoint['arch']](sobel=sob, out=int(N[0]))\\n #\\n # # deal with a dataparallel table\\n # def rename_key(key):\\n # if not 'module' in key:\\n # return key\\n # return ''.join(key.split('.module'))\\n #\\n # checkpoint['state_dict'] = {rename_key(key): val\\n # for key, val\\n # in checkpoint['state_dict'].items()}\\n #\\n # # load weights\\n # model.load_state_dict(checkpoint['state_dict'])\\n # print(\\\"Loaded\\\")\\n # else:\\n # model = None\\n # print(\\\"=> no checkpoint found at '{}'\\\".format(path))\\n\\n # net = models.__dict__['ResNet18'](low_dim=128)\\n # net = models.__dict__['resnet18'](low_dim=128)\\n\\n net = models.__dict__['alexnet'](out=128)\\n # net = models.__dict__['Alexnet_C'](out=args.low_dim)\\n\\n net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))\\n net.load_state_dict(checkpoint['net'])\\n\\n return net\",\n \"def train(self, config: ConfigurationNode = None):\\n if config is None:\\n config = self.config\\n # Create writable timestamp for easier record keeping\\n timestamp = datetime.now().isoformat(sep=\\\"T\\\", timespec=\\\"auto\\\")\\n name_timestamp = timestamp.replace(\\\":\\\", \\\"_\\\")\\n\\n # Start the mlflow run:\\n mlflow.start_run(run_name=name_timestamp)\\n\\n # Check valid output path, set path from the path_cfg_override modules respectively\\n assert config.OUTPUT_PATH != ''\\n path_output = config.OUTPUT_PATH # output folder\\n path_train = config.DATASET.TRAIN_DATA_PATH # training data folder\\n path_val = config.DATASET.VAL_DATA_PATH # validation data folder\\n\\n # Make output dir and its parents if not exist.\\n if not os.path.exists(path_output):\\n os.makedirs(path_output)\\n\\n # Make result folders if they do not exist.\\n self.results_dir = (Path(path_output) / name_timestamp)\\n if not os.path.exists(self.results_dir):\\n os.makedirs(self.results_dir)\\n\\n # Make backup folders if they do not exist.\\n self.backup_dir = os.path.join(self.results_dir, 'model_backups')\\n if not os.path.exists(self.backup_dir):\\n os.makedirs(self.backup_dir)\\n\\n writer_tensorboard = SummaryWriter(log_dir=Path(self.results_dir / \\\"logs_tensorflow\\\"))\\n\\n # Now that CFG has been properly merged with new data along the way, time to dump a version of it into a string for trackability purposes.\\n config.dump(stream=open(os.path.join(self.results_dir, f'config{name_timestamp}.yaml'), 'w'))\\n\\n # file path to store the state of the model.\\n state_fpath = os.path.join(self.results_dir, f'model{name_timestamp}.pt')\\n\\n # ????\\n perf_path = os.path.join(self.results_dir, f'trace{name_timestamp}.p')\\n perf_trace = []\\n\\n # Load data, create the data loader objects from them.\\n data_train = pickle.load(open(path_train, 'rb'))\\n data_val = pickle.load(open(path_val, 'rb'))\\n self.loader_train = build_data_loader(data_train, config.DATASET, True)\\n self.loader_val = build_data_loader(data_val, config.DATASET, False)\\n\\n # Build the model using configue dict node\\n self.model = build_model(config.MODEL)\\n\\n # Enable parallel multi GPU mode if the config specify it.\\n if config.MODEL.PARALLEL:\\n print(\\\"Utilized parallel processing\\\")\\n self.model = torch.nn.DataParallel(self.model)\\n\\n current_epoch = 0\\n\\n # For resuming training (i.e. load checkpoint)\\n if config.RESUME_PATH != \\\"\\\":\\n checkpoint = torch.load(config.RESUME_PATH, map_location='cpu')\\n current_epoch = checkpoint['epoch']\\n self.model.load_state_dict(checkpoint[\\\"model_state\\\"])\\n _ = self.model.cuda()\\n\\n # SOLVER EVALUATOR\\n cfg_solver = config.MODEL.SOLVER\\n\\n # Build optimizer (between train/validation, using the solver portion of the configuration.\\n optimizer = build_optimizer(self.model, cfg_solver)\\n\\n # Build evaluator (between train/validation, using the solver portion of the configuration.\\n evaluator = build_evaluator(cfg_solver)\\n\\n evaluator.float().cuda()\\n total_epochs = cfg_solver.TOTAL_EPOCHS\\n\\n\\n # Main training epoch loop starts here.\\n for epoch in range(current_epoch, total_epochs):\\n\\n # Train a single epoch\\n self.train_epoch(epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard)\\n\\n mlflow.end_run()\",\n \"def load_model_trainer_states_from_checkpoint(self, checkpoint_path, model=None):\\n import os\\n\\n if model is None:\\n try:\\n import cloudpickle\\n except ImportError:\\n raise ImportError(\\\"cloudpickle is required to load model class\\\")\\n logger.info(\\\"Loading model class\\\")\\n model = cloudpickle.load(open(os.path.join(checkpoint_path, \\\"model_class.pkl\\\"), \\\"rb\\\"))\\n\\n self.model = HFWrapper(model)\\n logger.info(\\\"Loading weights of previously trained model\\\")\\n # Restoring model weights\\n self.model.load_state_dict(\\n # torch.load(os.path.join(training_args.output_dir, \\\"pytorch_model.bin\\\"))\\n torch.load(os.path.join(checkpoint_path, \\\"pytorch_model.bin\\\"))\\n )\\n # Restoring random state\\n rng_file = os.path.join(checkpoint_path, \\\"rng_state.pth\\\")\\n checkpoint_rng_state = torch.load(rng_file)\\n random.setstate(checkpoint_rng_state[\\\"python\\\"])\\n np.random.set_state(checkpoint_rng_state[\\\"numpy\\\"])\\n torch.random.set_rng_state(checkpoint_rng_state[\\\"cpu\\\"])\\n torch.cuda.random.set_rng_state_all(checkpoint_rng_state[\\\"cuda\\\"])\\n # Restoring AMP scaler\\n if self.use_amp:\\n self.scaler.load_state_dict(torch.load(os.path.join(checkpoint_path, \\\"scaler.pt\\\")))\",\n \"def init_model(config: Union[str, Path, Config],\\n checkpoint: Optional[str] = None,\\n device: str = 'cuda:0',\\n cfg_options: Optional[dict] = None):\\n if isinstance(config, (str, Path)):\\n config = Config.fromfile(config)\\n elif not isinstance(config, Config):\\n raise TypeError('config must be a filename or Config object, '\\n 'but got {}'.format(type(config)))\\n if cfg_options is not None:\\n config.merge_from_dict(cfg_options)\\n elif 'init_cfg' in config.model.backbone:\\n config.model.backbone.init_cfg = None\\n config.model.pretrained = None\\n config.model.train_cfg = None\\n init_default_scope(config.get('default_scope', 'mmseg'))\\n\\n model = MODELS.build(config.model)\\n if checkpoint is not None:\\n checkpoint = load_checkpoint(model, checkpoint, map_location='cpu')\\n dataset_meta = checkpoint['meta'].get('dataset_meta', None)\\n # save the dataset_meta in the model for convenience\\n if 'dataset_meta' in checkpoint.get('meta', {}):\\n # mmseg 1.x\\n model.dataset_meta = dataset_meta\\n elif 'CLASSES' in checkpoint.get('meta', {}):\\n # < mmseg 1.x\\n classes = checkpoint['meta']['CLASSES']\\n palette = checkpoint['meta']['PALETTE']\\n model.dataset_meta = {'classes': classes, 'palette': palette}\\n else:\\n warnings.simplefilter('once')\\n warnings.warn(\\n 'dataset_meta or class names are not saved in the '\\n 'checkpoint\\\\'s meta data, classes and palette will be'\\n 'set according to num_classes ')\\n num_classes = model.decode_head.num_classes\\n dataset_name = None\\n for name in dataset_aliases.keys():\\n if len(get_classes(name)) == num_classes:\\n dataset_name = name\\n break\\n if dataset_name is None:\\n warnings.warn(\\n 'No suitable dataset found, use Cityscapes by default')\\n dataset_name = 'cityscapes'\\n model.dataset_meta = {\\n 'classes': get_classes(dataset_name),\\n 'palette': get_palette(dataset_name)\\n }\\n model.cfg = config # save the config in the model for convenience\\n model.to(device)\\n model.eval()\\n return model\",\n \"def restore_checkpoint(model, checkpoint_dir, cuda=False, force=False, pretrain=False):\\n try:\\n cp_files = [\\n file_\\n for file_ in os.listdir(checkpoint_dir)\\n if file_.startswith(\\\"epoch=\\\") and file_.endswith(\\\".checkpoint.pth.tar\\\")\\n ]\\n except FileNotFoundError:\\n cp_files = None\\n os.makedirs(checkpoint_dir)\\n if not cp_files:\\n print(\\\"No saved model parameters found\\\")\\n if force:\\n raise Exception(\\\"Checkpoint not found\\\")\\n else:\\n return model, 0, []\\n\\n # Find latest epoch\\n for i in itertools.count(1):\\n if \\\"epoch={}.checkpoint.pth.tar\\\".format(i) in cp_files:\\n epoch = i\\n else:\\n break\\n\\n if not force:\\n print(\\n \\\"Which epoch to load from? Choose in range [0, {}].\\\".format(epoch),\\n \\\"Enter 0 to train from scratch.\\\",\\n )\\n print(\\\">> \\\", end=\\\"\\\")\\n inp_epoch = int(input())\\n if inp_epoch not in range(epoch + 1):\\n raise Exception(\\\"Invalid epoch number\\\")\\n if inp_epoch == 0:\\n print(\\\"Checkpoint not loaded\\\")\\n clear_checkpoint(checkpoint_dir)\\n return model, 0, []\\n else:\\n print(\\\"Which epoch to load from? Choose in range [1, {}].\\\".format(epoch))\\n inp_epoch = int(input())\\n if inp_epoch not in range(1, epoch + 1):\\n raise Exception(\\\"Invalid epoch number\\\")\\n\\n filename = os.path.join(\\n checkpoint_dir, \\\"epoch={}.checkpoint.pth.tar\\\".format(inp_epoch)\\n )\\n\\n print(\\\"Loading from checkpoint {}?\\\".format(filename))\\n\\n if cuda:\\n checkpoint = torch.load(filename)\\n else:\\n # Load GPU model on CPU\\n checkpoint = torch.load(filename, map_location=lambda storage, loc: storage)\\n\\n try:\\n start_epoch = checkpoint[\\\"epoch\\\"]\\n stats = checkpoint[\\\"stats\\\"]\\n if pretrain:\\n model.load_state_dict(checkpoint[\\\"state_dict\\\"], strict=False)\\n else:\\n model.load_state_dict(checkpoint[\\\"state_dict\\\"])\\n print(\\n \\\"=> Successfully restored checkpoint (trained for {} epochs)\\\".format(\\n checkpoint[\\\"epoch\\\"]\\n )\\n )\\n except:\\n print(\\\"=> Checkpoint not successfully restored\\\")\\n raise\\n\\n return model, inp_epoch, stats\",\n \"def train_model(config: dict, load_weights=None, resume_epoch=None):\\n # Set GPU memory optimization\\n try:\\n physical_devices = tf.config.list_physical_devices(\\\"GPU\\\")\\n for index in range(len(physical_devices)):\\n try:\\n tf.config.experimental.set_memory_growth(physical_devices[index], True)\\n\\n except Exception as err:\\n print(\\\"[WARN]: Failed to set memory growth for {0}\\\".format(physical_devices[index]))\\n print(\\\"[WARN]: Error\\\", err, \\\" .Skipping memory optimization\\\")\\n\\n except Exception as err:\\n print(\\\"[WARN]: memory optimization failed. Error:\\\", err, \\\" . Skipping!\\\")\\n\\n # Set up random states\\n np.random.seed(100)\\n random.seed(100)\\n tf.random.set_seed(100)\\n\\n # Get the required configurations\\n no_of_epochs = config[\\\"no_of_epochs\\\"]\\n steps_per_epoch = config[\\\"steps_per_epoch\\\"] if config[\\\"steps_per_epoch\\\"] > 0 else None\\n\\n train_batch_size = config[\\\"train_batch_size\\\"]\\n val_batch_size = config[\\\"val_batch_size\\\"]\\n test_batch_size = config[\\\"test_batch_size\\\"]\\n\\n model_name = config[\\\"model_name\\\"]\\n\\n # Create the dataset\\n dataset_path = config[\\\"dataset_path\\\"]\\n dataset_family = config[\\\"dataset_family\\\"]\\n\\n # get width and height\\n image_width = config[\\\"image_width\\\"]\\n image_height = config[\\\"image_height\\\"]\\n initial_width = config[\\\"initial_width\\\"]\\n initial_height = config[\\\"initial_height\\\"]\\n\\n model_name = model_name + \\\"_\\\" + dataset_family\\n\\n print(\\\"[INFO]: Using Configuration: \\\\n\\\", config)\\n\\n # Set up environments\\n folders = [\\n \\\"./outputs/model_save/{0}/checkpoints/\\\".format(model_name),\\n \\\"./outputs/output_logs/{0}/csv_log/\\\".format(model_name),\\n \\\"./outputs/model_save/{0}/best_model/\\\".format(model_name),\\n \\\"./outputs/model_save/{0}/saved_model/\\\".format(model_name),\\n \\\"./outputs/output_logs/{0}/graphs/\\\".format(model_name)\\n ]\\n print(\\\"[INFO]: Setting up folders: \\\")\\n os_utilities.make_directories(paths=folders)\\n\\n # Load the dataset\\n print(\\\"[INFO]: Loading dataset\\\")\\n if dataset_family == \\\"CVC-ClinicDB\\\":\\n X, y = du.get_cvc_clinic_datapath(dataset_path)\\n elif dataset_family == \\\"Kvasir-Seg\\\":\\n X, y = du.get_kvasir_seg_datapath(dataset_path)\\n else:\\n print(\\\"[ERROR]: {0} dataset family is unrecognized or not supported!\\\".format(dataset_family))\\n raise NotImplementedError\\n\\n X_train, X_sided, y_train, y_sided = train_test_split(X, y, random_state=100, test_size=0.2)\\n X_val, X_test, y_val, y_test = train_test_split(X_sided, y_sided, random_state=100, test_size=0.5)\\n\\n print(\\\"[INFO]: Training set size: \\\", len(X_train))\\n print(\\\"[INFO]: Validation set size: \\\", len(X_val))\\n print(\\\"[INFO]: Testing set size: \\\", len(X_test))\\n\\n print(\\\"[INFO]: Loading Training set\\\")\\n train_datagen = du.DataGenerator(X_train,\\n y_train,\\n image_size=(image_width, image_height),\\n model_name=config[\\\"model_name\\\"],\\n batch_size=train_batch_size,\\n dataset_family=dataset_family,\\n initial_size=(initial_width, initial_height),\\n aug_config_path=\\\"./augmentation_config.yaml\\\",\\n shuffle=True)\\n\\n print(\\\"[INFO]: Loading Validation set\\\")\\n val_datagen = du.DataGenerator(X_val,\\n y_val,\\n image_size=(image_width, image_height),\\n model_name=config[\\\"model_name\\\"],\\n batch_size=val_batch_size,\\n dataset_family=dataset_family,\\n initial_size=None,\\n aug_config_path=None,\\n shuffle=False)\\n\\n print(\\\"[INFO]: Setting tf.data pipeline\\\")\\n train_steps = len(train_datagen) if steps_per_epoch is None else int(steps_per_epoch)\\n val_steps = len(val_datagen)\\n\\n train_dataset = train_datagen.get_tf_data()\\n val_dataset = val_datagen.get_tf_data()\\n\\n # Get the model, loss and metrics\\n print(\\\"[INFO]: Building the model - {0}\\\".format(model_name))\\n model = models.ModelSelector(config)\\n\\n # Load the weights if available\\n if load_weights is not None:\\n print(\\\"[INFO]: Load the weights from {0}\\\".format(load_weights))\\n model.load_weights(load_weights)\\n\\n # Setup Callbacks\\n print(\\\"[INFO]: Setting up training Callbacks and Optimizers. Its almost done\\\")\\n resume_epoch = 0 if resume_epoch is None else resume_epoch\\n overwrite = True if resume_epoch == 0 else False\\n\\n train_csv_logger = callbacks.CSVLogging(\\\"./outputs/output_logs/{0}/csv_log/train_log.csv\\\".format(model_name),\\n overwrite=overwrite)\\n valid_csv_logger = callbacks.CSVLogging(\\\"./outputs/output_logs/{0}/csv_log/valid_log.csv\\\".format(model_name),\\n overwrite=overwrite)\\n lr_reducer = callbacks.ReduceLROnPlateau(learning_rate=float(config[\\\"learning_rate\\\"]),\\n patience=4,\\n decay_rate=1E-1,\\n delta=0.0001,\\n min_lr=1E-7,\\n mode=\\\"min\\\")\\n\\n model_save_path = \\\"./outputs/model_save/{0}/\\\".format(model_name)\\n\\n # Setup Optimizer\\n optimizer = tf.keras.optimizers.Adam(learning_rate=float(config[\\\"learning_rate\\\"]))\\n\\n # Check for monitor\\n monitor_variable = 100.0 # Initialize a start max\\n\\n print(\\\"[INFO]: Setting up metrics\\\")\\n loss_avg = tf.keras.metrics.Mean(name=\\\"loss\\\")\\n f1_score_metric = tf.keras.metrics.Mean(name=\\\"f1_score\\\")\\n iou_coe_metric = tf.keras.metrics.Mean(name=\\\"iou_coe\\\")\\n dice_coe_metric = tf.keras.metrics.Mean(name=\\\"dice_coe\\\")\\n\\n # Set up a custom train loop\\n print(\\\"[INFO]: Beginning training loops\\\")\\n # Iterate epoch wise\\n for epoch in range(resume_epoch, no_of_epochs):\\n\\n print(\\\"Training {0}/{1}\\\".format(epoch + 1, no_of_epochs))\\n\\n try:\\n # Training-loop == using batches\\n train_loss, train_f1_score, train_iou, train_dice = train(config[\\\"model_name\\\"],\\n model,\\n train_dataset,\\n train_steps,\\n metrics_tracker=(loss_avg,\\n f1_score_metric,\\n iou_coe_metric,\\n dice_coe_metric),\\n optimizer=optimizer,\\n epoch=epoch + 1,\\n total_epochs=no_of_epochs)\\n\\n train_tracker = {\\n \\\"train_loss\\\": [train_loss],\\n \\\"train_f1_score\\\": [train_f1_score],\\n \\\"train_iou_coe\\\": [train_iou],\\n \\\"train_dice_coe\\\": [train_dice]\\n }\\n\\n # Validation loop == using batches\\n val_loss, val_f1_score, val_iou, val_dice = train(config[\\\"model_name\\\"],\\n model,\\n val_dataset,\\n val_steps,\\n metrics_tracker=(loss_avg,\\n f1_score_metric,\\n iou_coe_metric,\\n dice_coe_metric),\\n optimizer=None,\\n epoch=1,\\n total_epochs=1)\\n val_tracker = {\\n \\\"val_loss\\\": [val_loss],\\n \\\"val_f1_score\\\": [val_f1_score],\\n \\\"val_iou_coe\\\": [val_iou],\\n \\\"val_dice_coe\\\": [val_dice]\\n }\\n\\n model.save_weights(model_save_path + \\\"checkpoints/{0}_ckpt.h5\\\".format(model_name))\\n print(\\\"[INFO]: Epoch {0}/{1} - \\\\nTrain evaluation: {2}, \\\\nValidation evaluation: {3}\\\".\\n format(epoch + 1, no_of_epochs, train_tracker, val_tracker))\\n train_csv_logger.log(train_tracker)\\n valid_csv_logger.log(val_tracker)\\n\\n # Save the best model\\n if monitor_variable > val_loss:\\n monitor_variable = val_loss\\n model.save_weights(model_save_path + \\\"best_model/best_{0}.h5\\\".format(model_name))\\n\\n # LR Reduce\\n lr_reducer.check_lr(monitor_variable=val_loss, optimizer=optimizer)\\n\\n except KeyboardInterrupt:\\n print(\\\"[INFO]: Interrupted Training. Trying to save model\\\")\\n model.save_weights(model_save_path + \\\"{0}_{1}_interrupted.h5\\\".format(model_name, epoch + 1))\\n print(\\\"[INFO]: Attempting to run test on the best model so far!\\\")\\n break\\n\\n except Exception as err:\\n print(\\\"[ERROR]: Unexpected Critical Error: \\\", err)\\n print(\\\"[ERROR]: Trying to save the weights\\\")\\n model.save_weights(model_save_path + \\\"{0}_{1}_critical.h5\\\".format(model_name, epoch + 1))\\n traceback.print_exc()\\n sys.exit(2)\\n\\n print(\\\"[INFO]: Training completed. Saving model\\\")\\n model.save_weights(model_save_path + \\\"saved_model/{0}.h5\\\".format(model_name))\\n\\n print(\\\"[INFO]: Testing model\\\")\\n print(\\\"[INFO]: Loading Best saved model:\\\")\\n model.load_weights(model_save_path + \\\"best_model/best_{0}.h5\\\".format(model_name))\\n\\n print(\\\"[INFO]: Loading the test set\\\")\\n test_datagen = du.DataGenerator(X_test,\\n y_test,\\n image_size=(image_width, image_height),\\n model_name=config[\\\"model_name\\\"],\\n batch_size=test_batch_size,\\n dataset_family=dataset_family,\\n initial_size=None,\\n aug_config_path=None,\\n shuffle=False)\\n\\n print(\\\"[INFO]: Loading TF data\\\")\\n test_dataset = test_datagen.get_tf_data()\\n test_steps = len(test_datagen)\\n\\n print(\\\"[INFO]: Testing Initiated\\\")\\n test_loss, test_f1_score, test_iou, test_dice = train(config[\\\"model_name\\\"],\\n model,\\n test_dataset,\\n test_steps,\\n metrics_tracker=(loss_avg,\\n f1_score_metric,\\n iou_coe_metric,\\n dice_coe_metric),\\n optimizer=None,\\n epoch=1,\\n total_epochs=1)\\n test_tracker = {\\n \\\"test_loss\\\": [test_loss],\\n \\\"test_f1_score\\\": [test_f1_score],\\n \\\"test_iou_coe\\\": [test_iou],\\n \\\"test_dice_coe\\\": [test_dice]\\n }\\n print(\\\"[INFO]: Test Results: \\\\n\\\", test_tracker)\\n with open(\\\"./outputs/output_logs/{0}/test_results.txt\\\".format(model_name), mode=\\\"w\\\") as f:\\n f.write(\\\"Dumped Test Results for the model {0}\\\\n\\\".format(model_name))\\n for k, v in test_tracker.items():\\n f.write(\\\"{0} => {1}\\\\n\\\".format(k, v))\\n\\n print(\\\"[INFO]: Closing operations\\\")\",\n \"def load(cls, path):\\n print(f'load checkpoint from {path}')\\n if torch.cuda.is_available():\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\\n else:\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\\n \\n # model.flatten_parameters() # make RNN parameters contiguous\\n optimizer = resume_checkpoint['optimizer']\\n return Checkpoint(\\n model=model, \\n optimizer=optimizer,\\n epoch=resume_checkpoint['epoch'],\\n path=path\\n )\",\n \"def eval_model(config):\\n print 'Model directory: %s' % config.model_output\\n print 'Running model: %s' % config.model_type\\n if config.model_type == 'fully_connected_mlp':\\n from models.fully_connected_mlp import model_struct\\n elif config.model_type == 'fully_connected_mlp_2l':\\n from models.fully_connected_mlp_2l import model_struct\\n elif config.model_type == 'fully_connected_conv':\\n from models.fully_connected_conv import model_struct\\n elif config.model_type == 'vgg_feature_model':\\n from models.vgg_feature_model import model_struct\\n else:\\n raise Exception\\n\\n # Prepare model training\\n dt_stamp = re.split(\\n '\\\\.', str(datetime.now()))[0].\\\\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\\n dt_dataset = config.model_type + '_' + dt_stamp + '/'\\n config.train_checkpoint = os.path.join(\\n config.model_output, dt_dataset) # timestamp this run\\n config.summary_dir = os.path.join(\\n config.train_summaries, config.model_output, dt_dataset)\\n dir_list = [config.train_checkpoint, config.summary_dir]\\n [make_dir(d) for d in dir_list]\\n\\n # Prepare model inputs\\n train_data = os.path.join(config.tfrecord_dir, 'train.tfrecords')\\n validation_data = os.path.join(config.tfrecord_dir, 'val.tfrecords')\\n feat_mean = 0 # np.mean(np.load(config.mean_file)['feat_list'])\\n\\n # Prepare data on CPU\\n with tf.device('/cpu:0'):\\n train_images, train_labels = inputs(\\n tfrecord_file=train_data,\\n batch_size=config.train_batch,\\n num_feats=config.n_features,\\n sample=config.sample['train'],\\n max_pixels_per_image=config.max_pixels_per_image,\\n im_size=config.resize,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n num_epochs=config.epochs,\\n feat_mean_value=feat_mean)\\n val_images, val_labels = inputs(\\n tfrecord_file=validation_data,\\n batch_size=1,\\n num_feats=config.n_features,\\n sample=config.sample['val'],\\n max_pixels_per_image=config.max_pixels_per_image,\\n im_size=config.resize,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n num_epochs=config.epochs,\\n feat_mean_value=feat_mean)\\n tf.summary.image('validation images', tf.cast(val_labels, tf.float32))\\n\\n # Prepare model on GPU\\n with tf.device('/gpu:0'):\\n with tf.variable_scope('cnn') as scope:\\n\\n model = model_struct()\\n train_mode = tf.get_variable(name='training', initializer=True)\\n model.build(\\n features=train_images,\\n output_categories=len(config.labels.keys()),\\n train_mode=train_mode, batchnorm=config.batch_norm)\\n\\n # Prepare the cost function\\n cost = softmax_cost(\\n model.res_logits, train_labels, ratio=config.ratio,\\n label_reshape=[\\n config.batch_size * config.max_pixels_per_image])\\n train_op = tf.train.AdamOptimizer(config.lr).minimize(cost)\\n\\n tf.summary.scalar(\\\"cost\\\", cost)\\n\\n train_score = correlation(\\n model.prob, train_labels) # training accuracy\\n tf.summary.scalar(\\\"training correlation\\\", train_score)\\n\\n # Setup validation op\\n if validation_data is not False:\\n scope.reuse_variables()\\n # Validation graph is the same as training except no batchnorm\\n val_model = model_struct()\\n val_model.build(\\n features=val_images,\\n output_categories=len(config.labels.keys()))\\n\\n # Calculate validation accuracy\\n val_pred = tf.cast(\\n tf.reshape(\\n tf.argmax(\\n val_model.prob, axis=1),\\n [1, config.resize[0], config.resize[1], 1]),\\n tf.float32)\\n tf.summary.image('validation prediction', val_pred)\\n val_score = correlation(\\n val_model.prob, tf.reshape(\\n val_labels, [np.prod(config.resize), 1]))\\n tf.summary.scalar(\\\"validation correlation\\\", val_score)\\n\\n # Set up summaries and saver\\n saver = tf.train.Saver(\\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\\n summary_op = tf.summary.merge_all()\\n\\n # Initialize the graph\\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\\n\\n # Need to initialize both of these if supplying num_epochs to inputs\\n sess.run(tf.group(tf.global_variables_initializer(),\\n tf.local_variables_initializer()))\\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\\n\\n # Set up exemplar threading\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\\n\\n # Start training loop\\n np.save(config.train_checkpoint, config)\\n step, val_max, losses = 0, 0, []\\n train_acc = 0\\n try:\\n while not coord.should_stop():\\n start_time = time.time()\\n _, loss_value, train_acc = sess.run([train_op, cost, train_score])\\n losses.append(loss_value)\\n duration = time.time() - start_time\\n assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\\n\\n if step % 100 == 0 and step % 10 == 0:\\n if validation_data is not False:\\n _, val_acc, val_frame = sess.run(\\n [train_op, val_score, val_pred])\\n\\n np.save(\\n os.path.join(\\n config.model_output, '%s_val_image' % step),\\n val_frame)\\n else:\\n val_acc = -1 # Store every checkpoint\\n\\n # Summaries\\n summary_str = sess.run(summary_op)\\n summary_writer.add_summary(summary_str, step)\\n\\n # Training status and validation accuracy\\n format_str = (\\n '%s: step %d, loss = %.2f (%.1f examples/sec; '\\n '%.3f sec/batch) | Training r = %s | '\\n 'Validation r = %s | logdir = %s')\\n print (format_str % (\\n datetime.now(), step, loss_value,\\n config.train_batch / duration, float(duration),\\n train_acc, val_acc, config.summary_dir))\\n\\n # Save the model checkpoint if it's the best yet\\n if val_acc > val_max:\\n saver.save(\\n sess, os.path.join(\\n config.train_checkpoint,\\n 'model_' + str(step) + '.ckpt'), global_step=step)\\n\\n # Store the new max validation accuracy\\n val_max = val_acc\\n\\n else:\\n # Training status\\n format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; '\\n '%.3f sec/batch) | Training F = %s')\\n print (format_str % (datetime.now(), step, loss_value,\\n config.train_batch / duration,\\n float(duration), train_acc))\\n # End iteration\\n step += 1\\n\\n except tf.errors.OutOfRangeError:\\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\\n finally:\\n coord.request_stop()\\n\\n dt_stamp = get_dt() # date-time stamp\\n np.save(\\n os.path.join(\\n config.tfrecord_dir, '%straining_loss' % dt_stamp), losses)\\n coord.join(threads)\\n sess.close()\",\n \"def createModel(config_path, checkpoint_path, graph_path):\\n\\n global build_graph, prev_classes\\n\\n trt_graph = None\\n input_names = None\\n \\n if build_graph:\\n frozen_graph, input_names, output_names = build_detection_graph(\\n config=config_path,\\n checkpoint=checkpoint_path\\n )\\n \\n trt_graph = trt.create_inference_graph(\\n input_graph_def=frozen_graph,\\n outputs=output_names,\\n max_batch_size=1,\\n max_workspace_size_bytes=1 << 25,\\n precision_mode='FP16',\\n minimum_segment_size=50\\n )\\n\\n with open(graph_path, 'wb') as f:\\n f.write(trt_graph.SerializeToString())\\n\\n with open('config.txt', 'r+') as json_file: \\n data = json.load(json_file)\\n data['model'] = []\\n data['model'] = [{'input_names': input_names}]\\n json_file.seek(0)\\n json_file.truncate()\\n json.dump(data, json_file)\\n\\n else:\\n with open(graph_path, 'rb') as f:\\n trt_graph = tf.GraphDef()\\n trt_graph.ParseFromString(f.read())\\n with open('config.txt') as json_file: \\n data = json.load(json_file)\\n input_names = data['model'][0]['input_names']\\n\\n return Model(trt_graph, input_names)\",\n \"def _restore_checkpoint(self, checkpoint_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(checkpoint_path))\\n checkpoint = torch.load(checkpoint_path)\\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\\n \\n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\\n print('Parameters are inconsistant, adapting model parameters ...')\\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\\n del pretrained_dict['1']\\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\\n self.model.load_state_dict(model_dict)\\n else:\\n print('Parameters are consistant, load state dict directly ...')\\n self.model.load_state_dict(checkpoint['state_dict'])\\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\\n # if self.with_cuda:\\n # for state in self.optimizer.state.values():\\n # for k, v in state.items():\\n # if isinstance(v, torch.Tensor):\\n # state[k] = v.cuda(self.device)\",\n \"def load_model(self, checkpoint_path):\\n model = self.model_definition()\\n model.load_weights(checkpoint_path)\\n return model\",\n \"def load_model(self, fname: str) -> None:\\n checkpoint_data = torch.load(fname)\\n\\n # Load the models\\n # P-Net\\n model_import_path = checkpoint_data['p_net']['model_import_path']\\n imp = importlib.import_module(model_import_path)\\n mod = getattr(imp, checkpoint_data['p_net']['model_name'])\\n self.p_net = mod()\\n self.p_net.set_params(checkpoint_data['p_net'])\\n # Q-Net\\n model_import_path = checkpoint_data['q_net']['model_import_path']\\n imp = importlib.import_module(model_import_path)\\n mod = getattr(imp, checkpoint_data['q_net']['model_name'])\\n self.q_net = mod()\\n self.q_net.set_params(checkpoint_data['q_net'])\",\n \"def load_checkpoint(self, path: str = '', train: bool = True) -> int:\\n\\n if not path:\\n dir_ = os.path.dirname(os.path.realpath('__file__'))\\n path = os.path.join(dir_, 'model.pt')\\n\\n try:\\n ckpt = torch.load(path)\\n except FileNotFoundError:\\n return 0\\n else:\\n print('Loaded model at epoch: ', end='')\\n\\n self.load_state_dict(ckpt['model_state_dict'])\\n self.actor_optimizer.load_state_dict(ckpt['ac_optim_dict'])\\n self.critic_optimizer.load_state_dict(ckpt['critic_optim_dict'])\\n epoch = ckpt['epoch']\\n\\n print(epoch)\\n\\n if not train:\\n self.eval()\\n else:\\n self.train()\\n\\n return epoch\",\n \"def train(model_name, batch_size, steps_per_epoch, epochs, validation_steps, \\n model_file=None, save_path=None):\\n \\n print(\\\"- Loading configuration...\\\")\\n if model_name in models_default_params:\\n default_params = models_default_params[model_name]\\n else:\\n print(\\\"Error: the model '{}' has not been implemented\\\".format(model_name))\\n return\\n custom_objects = default_params['custom_objects']\\n patch_size = default_params['patch_size']\\n if save_path is None:\\n save_path = default_params['default_path']\\n if os.path.isfile(save_path):\\n print(\\\"Warning: {} is an existing file and will be overwritten.\\\".format(save_path))\\n print(\\\"- Configuration loaded.\\\")\\n \\n print(\\\"- Loading datasets...\\\")\\n train_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Training/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Training/Labels/\\\",\\n patch_size = patch_size)\\n val_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Validation/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Validation/Labels/\\\",\\n patch_size = patch_size)\\n print(\\\"- Data loaded.\\\")\\n \\n print(\\\"- Initialising model...\\\")\\n if(model_file is not None): # Further train existing model\\n model = keras.models.load_model(model_file, custom_objects=custom_objects)\\n else: # Create new model\\n if model_name == 'fcn':\\n model = fcn.make_fcn_resnet((patch_size, patch_size, channels), nb_labels, \\n use_pretraining=False, freeze_base=False)\\n elif model_name == 'pspnet':\\n model = pspnet.build_pspnet(nb_classes=nb_labels, resnet_layers=50,\\n input_shape=patch_size)\\n elif model_name == 'mobilenetv2':\\n model = mobilenetv2.MobileNetv2((patch_size, patch_size, channels), nb_labels) \\n\\n model.compile(\\n optimizer = optimizers.Adam(lr = 0.00001),\\n loss = losses.categorical_crossentropy,\\n metrics = [metrics.categorical_accuracy]) \\n model.summary() \\n print(\\\"- Model initialised.\\\")\\n \\n tensorboard = callbacks.TensorBoard(log_dir='./logs')\\n csv_logger = callbacks.CSVLogger('logs/training.csv')\\n checkpoint = callbacks.ModelCheckpoint(filepath=checkpoint_path,\\n save_weights_only=True,\\n save_best_only=True)\\n \\n print(\\\"- Starting training.\\\")\\n model.fit_generator(\\n generator=train_gen,\\n steps_per_epoch=steps_per_epoch,\\n epochs=epochs,\\n validation_data=val_gen,\\n validation_steps=validation_steps,\\n # callbacks=[checkpoint, csv_logger]\\n )\\n print(\\\"- Training complete.\\\")\\n \\n model.save(save_path)\\n print(\\\"- Model saved to {}\\\".format(save_path))\",\n \"def load_checkpoint(self):\\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\\n try:\\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\\n ckpt = torch.load(self.params.resume_from)\\n self.epoch = ckpt['epoch']\\n try:\\n self.train_loss = ckpt['train_loss']\\n self.val_loss = ckpt['val_loss']\\n except:\\n self.train_loss = []\\n self.val_loss = []\\n self.network.load_state_dict(ckpt['state_dict'])\\n self.opt.load_state_dict(ckpt['optimizer'])\\n LOG('Checkpoint Loaded!')\\n LOG('Current Epoch: %d' % self.epoch)\\n self.ckpt_flag = True\\n except:\\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\\n else:\\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')\",\n \"def initialize_model(session, model, train_dir, expect_exists):\\n print \\\"Looking for model at %s...\\\" % train_dir\\n ckpt = tf.train.get_checkpoint_state(train_dir)\\n v2_path = ckpt.model_checkpoint_path + \\\".index\\\" if ckpt else \\\"\\\"\\n if ckpt and (tf.gfile.Exists(ckpt.model_checkpoint_path) or tf.gfile.Exists(v2_path)):\\n print \\\"Reading model parameters from %s\\\" % ckpt.model_checkpoint_path\\n model.saver.restore(session, ckpt.model_checkpoint_path)\\n else:\\n if expect_exists:\\n raise Exception(\\\"There is no saved checkpoint at %s\\\" % train_dir)\\n else:\\n print \\\"There is no saved checkpoint at %s. Creating model with fresh parameters.\\\" % train_dir\\n session.run(tf.global_variables_initializer())\\n print 'Num params: %d' % sum(v.get_shape().num_elements() for v in tf.trainable_variables())\",\n \"def initialize_model(session, model, train_dir, expect_exists):\\n print \\\"Looking for model at %s...\\\" % train_dir\\n ckpt = tf.train.get_checkpoint_state(train_dir)\\n v2_path = ckpt.model_checkpoint_path + \\\".index\\\" if ckpt else \\\"\\\"\\n if ckpt and (tf.gfile.Exists(ckpt.model_checkpoint_path) or tf.gfile.Exists(v2_path)):\\n print \\\"Reading model parameters from %s\\\" % ckpt.model_checkpoint_path\\n model.saver.restore(session, ckpt.model_checkpoint_path)\\n else:\\n if expect_exists:\\n raise Exception(\\\"There is no saved checkpoint at %s\\\" % train_dir)\\n else:\\n print \\\"There is no saved checkpoint at %s. Creating model with fresh parameters.\\\" % train_dir\\n session.run(tf.global_variables_initializer())\\n print 'Num params: %d' % sum(v.get_shape().num_elements() for v in tf.trainable_variables())\",\n \"def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):\\n\\n config = kwargs.pop(\\\"config\\\", None)\\n state_dict = kwargs.pop(\\\"state_dict\\\", None)\\n cache_dir = kwargs.pop(\\\"cache_dir\\\", None)\\n from_tf = kwargs.pop(\\\"from_tf\\\", False)\\n from_hf = kwargs.pop(\\\"from_hf\\\", False)\\n output_loading_info = kwargs.pop(\\\"output_loading_info\\\", False)\\n default_gpu = kwargs.pop(\\\"default_gpu\\\", True)\\n\\n # Load config\\n assert config is not None\\n model_kwargs = kwargs\\n\\n # Load model\\n if pretrained_model_name_or_path in cls.pretrained_model_archive_map:\\n archive_file = cls.pretrained_model_archive_map[pretrained_model_name_or_path]\\n elif os.path.isdir(pretrained_model_name_or_path):\\n if from_tf:\\n # Directly load from a TensorFlow checkpoint\\n archive_file = os.path.join(pretrained_model_name_or_path, TF_WEIGHTS_NAME + \\\".index\\\")\\n else:\\n archive_file = os.path.join(pretrained_model_name_or_path, WEIGHTS_NAME)\\n else:\\n if from_tf:\\n # Directly load from a TensorFlow checkpoint\\n archive_file = pretrained_model_name_or_path + \\\".index\\\"\\n else:\\n archive_file = pretrained_model_name_or_path\\n # redirect to the cache, if necessary\\n try:\\n resolved_archive_file = cached_path(archive_file, cache_dir=cache_dir)\\n except EnvironmentError:\\n if pretrained_model_name_or_path in cls.pretrained_model_archive_map:\\n logger.error(\\\"Couldn't reach server at '{}' to download pretrained weights.\\\".format(archive_file))\\n else:\\n logger.error(\\n \\\"Model name '{}' was not found in model name list ({}). \\\"\\n \\\"We assumed '{}' was a path or url but couldn't find any file \\\"\\n \\\"associated to this path or url.\\\".format(\\n pretrained_model_name_or_path, \\\", \\\".join(cls.pretrained_model_archive_map.keys()), archive_file)\\n )\\n return None\\n if default_gpu:\\n if resolved_archive_file == archive_file:\\n logger.info(\\\"loading weights file {}\\\".format(archive_file))\\n else:\\n logger.info(\\\"loading weights file {} from cache at {}\\\".format(archive_file, resolved_archive_file))\\n\\n # Instantiate model.\\n model = cls(config, *model_args, **model_kwargs)\\n\\n if state_dict is None and not from_tf:\\n state_dict = torch.load(resolved_archive_file, map_location=\\\"cpu\\\")\\n if from_tf:\\n # Directly load from a TensorFlow checkpoint\\n return cls.load_tf_weights(model, config, resolved_archive_file[:-6]) # Remove the '.index'\\n\\n # Convert old format to new format if needed from a PyTorch state_dict\\n old_keys = []\\n new_keys = []\\n for key in state_dict.keys():\\n new_key = None\\n if \\\"gamma\\\" in key:\\n new_key = key.replace(\\\"gamma\\\", \\\"weight\\\")\\n if \\\"beta\\\" in key:\\n new_key = key.replace(\\\"beta\\\", \\\"bias\\\")\\n if new_key:\\n old_keys.append(key)\\n new_keys.append(new_key)\\n for old_key, new_key in zip(old_keys, new_keys):\\n state_dict[new_key] = state_dict.pop(old_key)\\n\\n # Rename Bert parameters for our framework\\n # NB: Assume 1 Bert layer is mapped to 1 layer only (cannot be used to init multiple layers)\\n old_keys = []\\n new_keys = []\\n nums = []\\n for key in state_dict.keys():\\n new_key = None\\n if \\\".layer.\\\" in key and from_hf:\\n num = int(key.split(\\\".layer.\\\")[-1].split(\\\".\\\")[0])\\n if \\\".attention.\\\" in key:\\n new_key = key.replace(\\\".layer.%d.attention.\\\" % num,\\n \\\".layer.%d.attention_\\\" % config.bert_layer2attn_sublayer.get(str(num), num))\\n elif \\\".intermediate.\\\" in key:\\n new_key = key.replace(\\\".layer.%d.intermediate.\\\" % num,\\n \\\".layer.%d.intermediate.\\\" % config.bert_layer2ff_sublayer.get(str(num), num))\\n elif \\\".output.\\\" in key:\\n new_key = key.replace(\\\".layer.%d.output.\\\" % num,\\n \\\".layer.%d.output.\\\" % config.bert_layer2ff_sublayer.get(str(num), num))\\n if new_key:\\n old_keys.append(key)\\n new_keys.append(new_key)\\n nums.append(num)\\n for old_key, new_key, _ in sorted(zip(old_keys, new_keys, nums), key=lambda x: x[2], reverse=True):\\n state_dict[new_key] = state_dict.pop(old_key)\\n\\n # Load from a PyTorch state_dict\\n missing_keys = []\\n unexpected_keys = []\\n error_msgs = []\\n # copy state_dict so _load_from_state_dict can modify it\\n metadata = getattr(state_dict, \\\"_metadata\\\", None)\\n state_dict = state_dict.copy()\\n if metadata is not None:\\n state_dict._metadata = metadata\\n\\n def load(module, prefix=\\\"\\\"):\\n local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {})\\n module._load_from_state_dict(\\n state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs,\\n )\\n for name, child in module._modules.items():\\n if child is not None:\\n load(child, prefix + name + \\\".\\\")\\n\\n # Make sure we are able to load base models as well as derived models (with heads)\\n start_prefix = \\\"\\\"\\n model_to_load = model\\n if not hasattr(model, cls.base_model_prefix) and any(\\n s.startswith(cls.base_model_prefix) for s in state_dict.keys()\\n ):\\n start_prefix = cls.base_model_prefix + \\\".\\\"\\n if hasattr(model, cls.base_model_prefix) and not any(\\n s.startswith(cls.base_model_prefix) for s in state_dict.keys()\\n ):\\n model_to_load = getattr(model, cls.base_model_prefix)\\n\\n logger.info(start_prefix)\\n load(model_to_load, prefix=start_prefix)\\n if len(missing_keys) > 0 and default_gpu:\\n logger.info(\\n \\\"Weights of {} not initialized from pretrained model: {}\\\".format(model.__class__.__name__, missing_keys)\\n )\\n if len(unexpected_keys) > 0 and default_gpu:\\n logger.info(\\n \\\"Weights from pretrained model not used in {}: {}\\\".format(model.__class__.__name__, unexpected_keys)\\n )\\n if len(error_msgs) > 0 and default_gpu:\\n raise RuntimeError(\\n \\\"Error(s) in loading state_dict for {}:\\\\n\\\\t{}\\\".format(model.__class__.__name__, \\\"\\\\n\\\\t\\\".join(error_msgs))\\n )\\n\\n if hasattr(model, \\\"tie_weights\\\"):\\n model.tie_weights() # make sure word embedding weights are still tied\\n\\n # Set model in evaluation mode to desactivate DropOut modules by default\\n model.eval()\\n\\n if output_loading_info:\\n loading_info = {\\n \\\"missing_keys\\\": missing_keys,\\n \\\"unexpected_keys\\\": unexpected_keys,\\n \\\"error_msgs\\\": error_msgs,\\n }\\n return model, loading_info\\n\\n return model\",\n \"def _load_weights_to_model(self, model: nn.Module,\\n checkpoint: Optional[dict],\\n cfg: Optional[ConfigType]) -> None:\\n if checkpoint is not None:\\n _load_checkpoint_to_model(model, checkpoint)\\n else:\\n warnings.warn('Checkpoint is not loaded, and the inference '\\n 'result is calculated by the randomly initialized '\\n 'model!')\",\n \"def prepare_model_optimizer_and_scheduler(self):\\n\\n ###################################################################\\n # MODEL PREPARATION\\n # -----------------\\n # - step 1: Initialize a random model from config\\n # - step 2: Load model weights from checkpoint if any\\n # - step 3: Move model to device (GPU)\\n ###################################################################\\n\\n # Initialize a random model according to a specific config:\\n # NOTE: here we load from a physical path instead of using a keyword\\n # as compute nodes may not allow downloading from online hubs\\n if self.is_character_bert:\\n model_config = CharacterBertConfig.from_pretrained(\\n os.path.join(WORKDIR, 'data', 'character-bert'))\\n model = CharacterBertForPreTraining(model_config)\\n else:\\n model_config = BertConfig.from_pretrained(\\n os.path.join(WORKDIR, 'data', 'bert-base-uncased'))\\n model = BertForPreTraining(model_config)\\n if self.is_main_process:\\n logging.info(\\n \\\"Initialized %s using Config:\\\\n%s\\\",\\n \\\"CharacterBERT\\\" if self.is_character_bert else \\\"BERT\\\",\\n model_config\\n )\\n\\n # Load checkpoint if any:\\n if not self.resume_pretraining:\\n # CASE: no checkpoint -> training from scratch\\n self.global_step = 0\\n if self.is_main_process:\\n logging.info(\\\"Pre-training from scratch (good luck!)\\\")\\n else:\\n if self.init_checkpoint:\\n # CASE: load checkpoint from direct path\\n self.global_step = 0\\n init_checkpoint = self.init_checkpoint\\n if self.is_main_process:\\n logging.info(\\n \\\"Resuming pre-training from specific checkpoint `%s`\\\",\\n init_checkpoint\\n )\\n else:\\n # CASE: load checkpoint from resume_step\\n if self.is_main_process:\\n logging.info(\\n \\\"Resuming pre-training from step `%s`. \\\"\\n \\\"Looking inside `output_directory` for checkpoints...\\\",\\n self.resume_step\\n )\\n\\n if self.resume_step == -1:\\n # CASE: resume_step == -1, load latest checkpoint\\n model_names = [\\n fname\\n for fname in os.listdir(self.output_directory)\\n if fname.endswith(\\\".pt\\\")]\\n assert model_names, \\\"Could not find any checkpoints to resume from.\\\"\\n self.resume_step = max([\\n int(x.split('.pt')[0].split('_')[1].strip())\\n for x in model_names]) # TODO: find a better way for this\\n if self.is_main_process:\\n logging.info(\\n \\\"Resuming from latest checkpoint: ckpt_%s.pt\\\",\\n self.resume_step\\n )\\n else:\\n # CASE: resume_step == X, load checkpoint: `ckpt_X.pt`\\n if self.is_main_process:\\n logging.info(\\n \\\"Resuming from checkpoint: ckpt_%s.pt\\\",\\n self.resume_step\\n )\\n self.global_step = self.resume_step\\n init_checkpoint = os.path.join(\\n self.output_directory, f\\\"ckpt_{self.resume_step}.pt\\\")\\n\\n # Load the actual checkpoint file\\n self.checkpoint = torch.load(\\n init_checkpoint, map_location=\\\"cpu\\\"\\n )\\n\\n # NOTE: Keeping these lines below as a reminder that re-training on\\n # a different domain with CharacterBERT requires changing the\\n # output layer with a topK tokens matrix from the new domain.\\n\\n # # Case where we would retrain a general_domain CharacterBERT\\n # # on the medical domain. Don't use the general domain output layer:\\n # if self.is_medical_domain and self.is_character_bert and (not self.phase2):\\n # model.load_state_dict(\\n # {\\n # k: v for (k, v) in self.checkpoint['model'].items()\\n # # Don't load output matrix from general domain model\\n # if not k.startswith('cls.predictions') # ignoring the old output layer\\n # },\\n # strict=False)\\n # if self.is_main_process:\\n # logging.warning(\\n # \\\"Loaded model weights from `%s`, \\\"\\n # \\\"but ignored the `cls.predictions` module.\\\",\\n # init_checkpoint)\\n\\n # # General case: load weights from checkpoint\\n # else:\\n # model.load_state_dict(self.checkpoint['model'], strict=True)\\n # if self.is_main_process:\\n # logging.info('Loaded model weights from `%s`',\\n # init_checkpoint)\\n\\n # General case: load weights from checkpoint\\n model.load_state_dict(self.checkpoint['model'], strict=True)\\n if self.is_main_process:\\n logging.info('Loaded model weights from `%s`', init_checkpoint)\\n\\n # Deduce previous steps from phase1 when in phase2\\n if self.phase2 and not self.init_checkpoint:\\n self.global_step -= self.phase1_end_step\\n\\n if self.is_main_process:\\n logging.info(\\\"Training will start at global_step=%s\\\", self.global_step)\\n\\n # Move model to GPU:\\n model.to(self.device)\\n if self.is_main_process:\\n logging.info(\\\"Model was moved to device: %s\\\", self.device)\\n\\n ###################################################################\\n # OPTIMIZER / SCHEDULER PREPARATION\\n # ---------------------------------\\n # - step 1: Define the optimizer (FusedLAMB w/ some weight decay)\\n # - step 2: Define the learning rate scheduler (PolyWarmUpScheduler)\\n ###################################################################\\n\\n # Initialize an optimizer:\\n no_decay = ['bias', 'gamma', 'beta', 'LayerNorm'] # no weight decay\\n optimizer_grouped_parameters = [\\n {\\n 'params': [\\n param for name, param in model.named_parameters()\\n if not any((nd in name) for nd in no_decay)],\\n 'weight_decay': 0.01\\n },\\n {\\n 'params': [\\n param for name, param in model.named_parameters()\\n if any((nd in name) for nd in no_decay)],\\n 'weight_decay': 0.0\\n }\\n ]\\n optimizer = FusedLAMB(\\n optimizer_grouped_parameters, lr=self.learning_rate)\\n if self.is_main_process:\\n logging.info(\\\"Using optimizer: %s\\\", optimizer)\\n\\n # Initialize a learning rate scheduler:\\n self.lr_scheduler = PolyWarmUpScheduler(\\n optimizer,\\n warmup=self.warmup_proportion,\\n total_steps=self.total_steps\\n )\\n if self.is_main_process:\\n logging.info(\\\"Using scheduler: %s\\\", self.lr_scheduler)\\n\\n ###################################################################\\n # OTHER PREPARATION STEPS\\n # -----------------------\\n # - step 1: Set up Mixed Precision training (fp16) if required\\n # - step 2: Load optimizer stat from checkpoint if any\\n # - step 2: Set up DataParallel\\n ###################################################################\\n\\n # Set up fp16:\\n if self.fp16:\\n if self.is_main_process:\\n logging.info(\\\"Setting up `Almost FP16` Mixed Precision...\\\")\\n if self.loss_scale == 0:\\n model, optimizer = amp.initialize(\\n model, optimizer, opt_level=\\\"O2\\\", loss_scale=\\\"dynamic\\\")\\n else:\\n model, optimizer = amp.initialize(\\n model, optimizer, opt_level=\\\"O2\\\", loss_scale=self.loss_scale)\\n amp._amp_state.loss_scalers[0]._loss_scale = 2**20\\n\\n # Load optimizer state from checkpoint\\n if self.resume_pretraining:\\n if self.is_main_process:\\n logging.info(\\\"Loading optimizer state from checkpoint...\\\")\\n if self.phase2 or self.init_checkpoint:\\n keys = list(self.checkpoint['optimizer']['state'].keys())\\n # Override hyperparameters from previous self.checkpoint\\n for key in keys:\\n self.checkpoint['optimizer']['state'][key]['step'] = self.global_step\\n for i, _ in enumerate(self.checkpoint['optimizer']['param_groups']):\\n self.checkpoint['optimizer']['param_groups'][i]['step'] = self.global_step\\n self.checkpoint['optimizer']['param_groups'][i]['t_total'] = self.total_steps\\n self.checkpoint['optimizer']['param_groups'][i]['warmup'] = self.warmup_proportion\\n self.checkpoint['optimizer']['param_groups'][i]['lr'] = self.learning_rate\\n if self.is_main_process:\\n logging.info(\\\"Overwrote the following parameters with new values:\\\")\\n logging.info(\\\"* step: %s\\\", self.global_step)\\n logging.info(\\\"* t_total: %s\\\", self.total_steps)\\n logging.info(\\\"* warmup: %s\\\", self.warmup_proportion)\\n logging.info(\\\"* lr: %s\\\", self.learning_rate)\\n optimizer.load_state_dict(self.checkpoint['optimizer'])\\n # Restore AMP master parameters\\n if self.fp16:\\n if self.is_main_process:\\n logging.info(\\\"Restoring AMP master parameters (optimizer)...\\\")\\n optimizer._lazy_init_maybe_master_weights()\\n optimizer._amp_stash.lazy_init_called = True\\n optimizer.load_state_dict(self.checkpoint['optimizer'])\\n for param, saved_param in zip(amp.master_params(optimizer), self.checkpoint['master params']):\\n param.data.copy_(saved_param.data)\\n\\n # Distribute model\\n if self.training_is_distributed:\\n if not self.allreduce_post_accumulation:\\n model = DistributedDataParallel(\\n model,\\n message_size=250000000,\\n gradient_predivide_factor=\\\\\\n torch.distributed.get_world_size()\\n )\\n else:\\n flat_dist_call(\\n [param.data for param in model.parameters()],\\n torch.distributed.broadcast,\\n (0,)\\n )\\n elif self.n_gpu > 1:\\n model = torch.nn.DataParallel(model)\\n\\n # Set the values of self.model and self.optimizer\\n self.model = model\\n self.optimizer = optimizer\",\n \"def train_and_eval(config, babas_data):\\n\\n if config.resume_from_checkpoint is not None:\\n try:\\n if config.augment_background == 'background':\\n bg = config.augment_background\\n else:\\n bg = None\\n rfc = config.resume_from_checkpoint\\n ic = config.include_validation\\n print 'Loading saved config: %s' % config.saved_config\\n config = np.load(config.saved_config).item()\\n config.resume_from_checkpoint = rfc\\n config.include_validation = ic\\n if not hasattr(config, 'augment_background'):\\n config.augment_background = 'constant'\\n if not hasattr(config, 'background_folder'):\\n config.background_folder = 'backgrounds'\\n if bg is not None:\\n print 'Overriding saved config to add kinect backgrounds to training.'\\n config.augment_background = bg\\n results_dir = rfc\\n except:\\n print 'Relying on default config file.'\\n\\n if babas_data: # Shitty naive training method\\n config.tfrecord_dir = '/media/data_cifs/monkey_tracking/data_for_babas/tfrecords_from_babas'\\n config.babas_tfrecord_dir = config.tfrecord_dir\\n config.steps_before_validation = 20\\n config.epochs = 2000\\n config.convert_labels_to_pixel_space = False\\n config.augment_background = 'constant'\\n\\n # Import your model\\n print 'Model directory: %s' % config.model_output\\n print 'Running model: %s' % config.model_type\\n model_file = import_cnn(config.model_type)\\n\\n # Prepare model training\\n dt_stamp = re.split(\\n '\\\\.', str(datetime.now()))[0].\\\\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\\n dt_dataset = '%s_%s' % (config.model_type, dt_stamp)\\n if config.selected_joints is not None:\\n dt_dataset = '_%s' % (config.selected_joints) + dt_dataset\\n config.train_checkpoint = os.path.join(\\n config.model_output, dt_dataset) # timestamp this run\\n config.summary_dir = os.path.join(\\n config.train_summaries, dt_dataset)\\n results_dir = os.path.join(config.npy_dir, dt_dataset)\\n print 'Saving Dmurphy\\\\'s online updates to: %s' % results_dir\\n dir_list = [config.train_checkpoint, config.summary_dir, results_dir]\\n [tf_fun.make_dir(d) for d in dir_list]\\n\\n # Prepare model inputs\\n train_data = os.path.join(config.tfrecord_dir, config.train_tfrecords)\\n if config.babas_tfrecord_dir is not None:\\n train_babas_tfrecord_dir = os.path.join(\\n config.babas_tfrecord_dir,\\n config.train_tfrecords)\\n if config.include_validation or config.include_validation is None:\\n val_babas_tfrecord_dir = os.path.join(\\n config.babas_tfrecord_dir,\\n config.val_tfrecords)\\n else:\\n train_babas_tfrecord_dir = None\\n val_babas_tfrecord_dir = None\\n\\n if isinstance(config.include_validation, basestring):\\n validation_data = config.include_validation\\n elif config.include_validation == True:\\n validation_data = os.path.join(\\n config.tfrecord_dir,\\n config.val_tfrecords)\\n else:\\n validation_data = None\\n\\n print 'Using training set: %s' % train_data\\n print 'Using validation set: %s' % validation_data\\n\\n # Prepare data on CPU\\n with tf.device('/cpu:0'):\\n train_data_dict = inputs(\\n tfrecord_file=train_data,\\n batch_size=config.train_batch,\\n im_size=config.resize,\\n target_size=config.image_target_size,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n label_shape=config.num_classes,\\n num_epochs=config.epochs,\\n image_target_size=config.image_target_size,\\n image_input_size=config.image_input_size,\\n maya_conversion=config.maya_conversion,\\n max_value=config.max_depth,\\n normalize_labels=config.normalize_labels,\\n aux_losses=config.aux_losses,\\n selected_joints=config.selected_joints,\\n joint_names=config.joint_order,\\n num_dims=config.num_dims,\\n keep_dims=config.keep_dims,\\n mask_occluded_joints=config.mask_occluded_joints,\\n background_multiplier=config.background_multiplier,\\n augment_background=config.augment_background,\\n background_folder=config.background_folder,\\n randomize_background=config.randomize_background,\\n maya_joint_labels=config.labels,\\n babas_tfrecord_dir=train_babas_tfrecord_dir,\\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\\n image_target_size_is_flipped=config.image_target_size_is_flipped)\\n train_data_dict['deconv_label_size'] = len(config.labels)\\n\\n val_data_dict = inputs(\\n tfrecord_file=validation_data,\\n batch_size=config.validation_batch,\\n im_size=config.resize,\\n target_size=config.image_target_size,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n label_shape=config.num_classes,\\n num_epochs=config.epochs,\\n image_target_size=config.image_target_size,\\n image_input_size=config.image_input_size,\\n maya_conversion=config.maya_conversion,\\n max_value=config.max_depth,\\n normalize_labels=config.normalize_labels,\\n aux_losses=config.aux_losses,\\n selected_joints=config.selected_joints,\\n joint_names=config.joint_order,\\n num_dims=config.num_dims,\\n keep_dims=config.keep_dims,\\n mask_occluded_joints=config.mask_occluded_joints,\\n background_multiplier=config.background_multiplier,\\n augment_background='none',\\n background_folder=config.background_folder,\\n randomize_background=None,\\n maya_joint_labels=config.labels,\\n babas_tfrecord_dir=val_babas_tfrecord_dir,\\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\\n image_target_size_is_flipped=config.image_target_size_is_flipped)\\n val_data_dict['deconv_label_size'] = len(config.labels)\\n\\n # Check output_shape\\n if config.selected_joints is not None:\\n print 'Targeting joint: %s' % config.selected_joints\\n joint_shape = len(config.selected_joints) * config.keep_dims\\n if (config.num_classes // config.keep_dims) > (joint_shape):\\n print 'New target size: %s' % joint_shape\\n config.num_classes = joint_shape\\n\\n with tf.device('/gpu:0'):\\n with tf.variable_scope('cnn') as scope:\\n print 'Creating training graph:'\\n model = model_file.model_struct(\\n weight_npy_path=config.weight_npy_path)\\n train_mode = tf.get_variable(name='training', initializer=True)\\n model.build(\\n rgb=train_data_dict['image'],\\n target_variables=train_data_dict,\\n train_mode=train_mode,\\n batchnorm=config.batch_norm)\\n train_mu, train_var = tf.nn.moments(train_data_dict['image'], axes=[1, 2, 3])\\n tf.summary.histogram(\\\"train image mean\\\", train_mu)\\n tf.summary.histogram(\\\"train image std\\\", tf.sqrt(train_var))\\n if 'deconv_image' in config.aux_losses:\\n tf.summary.image('Deconv train', model.deconv)\\n if 'deconv_label' in config.aux_losses:\\n tf.summary.image(\\n 'Deconv label train',\\n tf.expand_dims(\\n tf.cast(\\n tf.argmax(model.deconv, axis=3), tf.float32), 3))\\n\\n # Setup validation op\\n if validation_data is not False:\\n scope.reuse_variables()\\n print 'Creating validation graph:'\\n val_model = model_file.model_struct()\\n val_model.build(\\n rgb=val_data_dict['image'],\\n target_variables=val_data_dict)\\n\\n # Calculate validation accuracy\\n val_mu, val_var = tf.nn.moments(val_data_dict['image'], axes=[1, 2, 3])\\n tf.summary.histogram(\\\"validation image mean\\\", val_mu)\\n tf.summary.histogram(\\\"validation image std\\\", tf.sqrt(val_var))\\n if 'label' in val_data_dict.keys():\\n # val_score = tf.reduce_mean(\\n # tf_fun.l2_loss(\\n # val_model.output, val_data_dict['label']))\\n if config.keep_dims == 3:\\n z_mask = tf.expand_dims(tf.tile([1, 1, 0], [int(val_data_dict['label'].get_shape()[-1]) // 3]), axis=0)\\n z_mask = tf.cast(z_mask, tf.float32)\\n val_model.output = val_model.output * z_mask\\n val_data_dict['label'] = val_data_dict['label'] * z_mask \\n val_score = tf.reduce_mean(tf.nn.l2_loss(val_model.output - val_data_dict['label']))\\n tf.summary.scalar(\\\"validation mse\\\", val_score)\\n if 'fc' in config.aux_losses:\\n tf.summary.image('FC val activations', val_model.final_fc)\\n if 'deconv_image' in config.aux_losses:\\n tf.summary.image('Deconv val', val_model.deconv)\\n if 'deconv_label' in config.aux_losses:\\n tf.summary.image(\\n 'Deconv label train',\\n tf.expand_dims(\\n tf.cast(\\n tf.argmax(val_model.deconv, axis=3),\\n tf.float32), 3))\\n tf.summary.image(\\n 'validation images',\\n tf.cast(val_data_dict['image'], tf.float32))\\n\\n # Prepare the loss functions:::\\n loss_list, loss_label = [], []\\n if 'label' in train_data_dict.keys():\\n # 1. Joint localization loss\\n if config.calculate_per_joint_loss == 'thomas':\\n label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\\n model=model,\\n train_data_dict=train_data_dict,\\n config=config,\\n y_key='label',\\n yhat_key='output')\\n loss_list += [label_loss]\\n elif config.calculate_per_joint_loss == 'skeleton':\\n label_loss = tf_fun.skeleton_loss(\\n model=model,\\n train_data_dict=train_data_dict,\\n config=config,\\n y_key='label',\\n yhat_key='output')\\n loss_list += [label_loss]\\n elif config.calculate_per_joint_loss == 'skeleton and joint':\\n label_loss = tf_fun.skeleton_loss(\\n model=model,\\n train_data_dict=train_data_dict,\\n config=config,\\n y_key='label',\\n yhat_key='output')\\n loss_list += [label_loss]\\n loss_label += ['skeleton loss']\\n delta = model['output'] - train_data_dict['label']\\n proc_weights = np.asarray(\\n config.dim_weight)[None,:].repeat(\\n len(config.joint_names), axis=0).reshape(1, -1)\\n delta *= proc_weights\\n # label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\\n # model=model,\\n # train_data_dict=train_data_dict,\\n # config=config,\\n # y_key='label',\\n # yhat_key='output')\\n # loss_list += [label_loss]\\n loss_list += [tf.nn.l2_loss(\\n model['output'] - train_data_dict['label'])]\\n else:\\n loss_list += [tf.nn.l2_loss(\\n model['output'] - train_data_dict['label'])]\\n loss_label += ['combined head']\\n for al in loss_helper.potential_aux_losses():\\n loss_list, loss_label = loss_helper.get_aux_losses(\\n loss_list=loss_list,\\n loss_label=loss_label,\\n train_data_dict=train_data_dict,\\n model=model,\\n aux_loss_dict=al,\\n domain_adaptation=train_babas_tfrecord_dir)\\n loss = tf.add_n(loss_list)\\n\\n # Add wd if necessary\\n if config.wd_penalty is not None:\\n _, l2_wd_layers = tf_fun.fine_tune_prepare_layers(\\n tf.trainable_variables(), config.wd_layers)\\n l2_wd_layers = [\\n x for x in l2_wd_layers if 'biases' not in x.name]\\n if config.wd_type == 'l1':\\n loss += (config.wd_penalty * tf.add_n(\\n [tf.reduce_sum(tf.abs(x)) for x in l2_wd_layers]))\\n elif config.wd_type == 'l2':\\n loss += (config.wd_penalty * tf.add_n(\\n [tf.nn.l2_loss(x) for x in l2_wd_layers]))\\n\\n optimizer = loss_helper.return_optimizer(config.optimizer)\\n optimizer = optimizer(config.lr)\\n\\n if hasattr(config, 'fine_tune_layers') and config.fine_tune_layers is not None:\\n print 'Finetuning learning for: %s' % config.fine_tune_layers\\n train_op, grads = tf_fun.finetune_learning(\\n loss,\\n trainables=tf.trainable_variables(),\\n fine_tune_layers=config.fine_tune_layers,\\n config=config\\n )\\n else:\\n # Op to calculate every variable gradient\\n grads = optimizer.compute_gradients(\\n loss, tf.trainable_variables())\\n # Op to update all variables according to their gradient\\n train_op = optimizer.apply_gradients(\\n grads_and_vars=grads)\\n\\n # Summarize all gradients and weights\\n [tf.summary.histogram(\\n var.name + '/gradient', grad)\\n for grad, var in grads if grad is not None]\\n # train_op = optimizer.minimize(loss)\\n\\n # Summarize losses\\n [tf.summary.scalar(lab, il) for lab, il in zip(\\n loss_label, loss_list)]\\n\\n # Summarize images and l1 weights\\n tf.summary.image(\\n 'train images',\\n tf.cast(train_data_dict['image'], tf.float32))\\n tf_fun.add_filter_summary(\\n trainables=tf.trainable_variables(),\\n target_layer='conv1_1_filters')\\n\\n # Set up summaries and saver\\n saver = tf.train.Saver(\\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\\n summary_op = tf.summary.merge_all()\\n tf.add_to_collection('output', model.output)\\n\\n # Initialize the graph\\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\\n\\n # Need to initialize both of these if supplying num_epochs to inputs\\n sess.run(tf.group(tf.global_variables_initializer(),\\n tf.local_variables_initializer()))\\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\\n\\n # Set up exemplar threading\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\\n\\n # Create list of variables to run through training model\\n train_session_vars = {\\n 'train_op': train_op,\\n 'loss_value': loss,\\n 'im': train_data_dict['image'],\\n 'yhat': model.output,\\n 'ytrue': train_data_dict['label']\\n }\\n if hasattr(model, 'deconv'):\\n train_session_vars['deconv'] = model.deconv\\n if hasattr(model, 'final_fc'):\\n train_session_vars['fc'] = model.final_fc\\n\\n # Create list of variables to run through validation model\\n val_session_vars = {\\n 'val_acc': val_score,\\n 'val_pred': val_model.output,\\n 'val_ims': val_data_dict['image'],\\n 'val_true': val_data_dict['label'],\\n }\\n\\n # Create list of variables to save to numpys\\n save_training_vars = [\\n 'im',\\n 'yhat',\\n 'ytrue',\\n 'yhat'\\n ]\\n\\n for al in loss_helper.potential_aux_losses():\\n if al.keys()[0] in train_data_dict.keys():\\n y_key = '%s' % al.keys()[0]\\n train_session_vars[y_key] = train_data_dict[al.values()[0]['y_name']]\\n save_training_vars += [y_key]\\n\\n yhat_key = '%s_hat' % al.keys()[0]\\n train_session_vars[yhat_key] = model[al.values()[0]['model_name']]\\n save_training_vars += [yhat_key]\\n\\n # Start training loop\\n np.save(config.train_checkpoint, config)\\n step, losses = 0, []\\n num_joints = int(\\n train_data_dict['label'].get_shape()[-1]) // config.keep_dims\\n normalize_vec = tf_fun.get_normalization_vec(config, num_joints)\\n if config.resume_from_checkpoint is not None:\\n if '.ckpt' in config.resume_from_checkpoint:\\n ckpt = config.resume_from_checkpoint\\n 'Restoring specified checkpoint: %s' % config.resume_from_checkpoint\\n else:\\n ckpt = tf.train.latest_checkpoint(config.resume_from_checkpoint)\\n print 'Evaluating checkpoint: %s' % ckpt\\n saver.restore(sess, ckpt)\\n try:\\n while not coord.should_stop():\\n start_time = time.time()\\n train_out_dict = sess.run(train_session_vars.values())\\n train_out_dict = {k: v for k, v in zip(\\n train_session_vars.keys(), train_out_dict)}\\n losses.append(train_out_dict['loss_value'])\\n duration = time.time() - start_time\\n assert not np.isnan(\\n train_out_dict['loss_value']), 'Model diverged with loss = NaN'\\n if step % config.steps_before_validation == 0:\\n if validation_data is not False:\\n val_out_dict = sess.run(\\n val_session_vars.values())\\n val_out_dict = {k: v for k, v in zip(\\n val_session_vars.keys(), val_out_dict)}\\n # if config.normalize_labels:\\n # val_out_dict['val_pred'] *= normalize_vec\\n # val_out_dict['val_true'] *= normalize_vec\\n np.savez(\\n os.path.join(\\n results_dir, '%s_val_coors' % step),\\n val_pred=val_out_dict['val_pred'],\\n val_ims=val_out_dict['val_ims'],\\n val_true=val_out_dict['val_true'],\\n normalize_vec=normalize_vec)\\n with open(\\n os.path.join(\\n results_dir, '%s_config.p' % step), 'wb') as fp:\\n pickle.dump(config, fp)\\n\\n # Summaries\\n summary_str = sess.run(summary_op)\\n summary_writer.add_summary(summary_str, step)\\n\\n # Training status and validation accuracy attach 9177\\n format_str = (\\n '%s: step %d, loss = %.8f (%.1f examples/sec; '\\n '%.3f sec/batch) | '\\n 'Validation l2 loss = %s | logdir = %s')\\n print (format_str % (\\n datetime.now(), step, train_out_dict['loss_value'],\\n config.train_batch / duration, float(duration),\\n val_out_dict['val_acc'],\\n config.summary_dir))\\n\\n # Save the model checkpoint if it's the best yet\\n if config.normalize_labels:\\n train_out_dict['yhat'] *= normalize_vec\\n train_out_dict['ytrue'] *= normalize_vec\\n [save_training_data(\\n output_dir=results_dir,\\n data=train_out_dict[k],\\n name='%s_%s' % (k, step)) for k in save_training_vars]\\n saver.save(\\n sess, os.path.join(\\n config.train_checkpoint,\\n 'model_' + str(step) + '.ckpt'), global_step=step)\\n\\n else:\\n # Training status\\n format_str = ('%s: step %d, loss = %.8f (%.1f examples/sec; '\\n '%.3f sec/batch)')\\n print (format_str % (\\n datetime.now(),\\n step,\\n train_out_dict['loss_value'],\\n config.train_batch / duration,\\n float(duration)))\\n # End iteration\\n step += 1\\n\\n except tf.errors.OutOfRangeError:\\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\\n finally:\\n coord.request_stop()\\n dt_stamp = get_dt() # date-time stamp\\n np.save(\\n os.path.join(\\n config.tfrecord_dir, '%s_training_loss' % dt_stamp), losses)\\n coord.join(threads)\\n sess.close()\",\n \"def load_ckpt(self, name=None):\\r\\n name = name if name == 'latest' else \\\"ckpt_epoch{}\\\".format(name)\\r\\n load_path = os.path.join(self.model_dir, \\\"{}.pth\\\".format(name))\\r\\n if not os.path.exists(load_path):\\r\\n raise ValueError(\\\"Checkpoint {} not exists.\\\".format(load_path))\\r\\n\\r\\n checkpoint = torch.load(load_path)\\r\\n print(\\\"Checkpoint loaded from {}\\\".format(load_path))\\r\\n if isinstance(self.net, nn.DataParallel):\\r\\n self.net.module.load_state_dict(checkpoint['model_state_dict'])\\r\\n else:\\r\\n self.net.load_state_dict(checkpoint['model_state_dict'])\\r\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\r\\n self.scheduler.load_state_dict(checkpoint['scheduler_state_dict'])\\r\\n self.clock.restore_checkpoint(checkpoint['clock'])\",\n \"def initialize_model_from_cfg(args, gpu_id=0):\\n model = eval(args.model).loot_model(args)\\n model.eval()\\n\\n if args.cuda:\\n model.cuda()\\n\\n if args.load_ckpt:\\n load_name = args.load_ckpt\\n logger.info(\\\"loading checkpoint %s\\\", load_name)\\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\\n net_utils.load_ckpt(model, checkpoint['model'])\\n\\n if args.load_detectron:\\n logger.info(\\\"loading detectron weights %s\\\", args.load_detectron)\\n load_detectron_weight(model, args.load_detectron)\\n\\n\\n return model\",\n \"def load_model(path, model, optimizer):\\n print(\\\"LOADING MODEL...\\\")\\n ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)\\n status = ckpt.restore(tf.train.latest_checkpoint(path))\\n ckpt_manager = tf.train.CheckpointManager(\\n checkpoint=ckpt, \\n directory=FLAGS.model_dir, \\n max_to_keep=3 \\n )\\n return model, optimizer, ckpt, ckpt_manager\",\n \"def train_and_evaluate(\\n model_name: str,\\n job_log_dir: Optional[str],\\n multi_host_checkpointing: Optional[bool],\\n maybe_use_persistence_checkpointing: bool,\\n restore_checkpoint_dir: Optional[str],\\n restore_checkpoint_step: Optional[int],\\n eval_on_test: Optional[bool],\\n checkpoint_todelete_subdir: Optional[str] = None) -> None:\\n model_config = model_utils.get_model(model_name)()\\n _write_params_file(model_config, job_log_dir)\\n task_p = model_config.task()\\n\\n input_p = model_config.datasets()\\n # Note that we modify input params below with runtime information, therefore\\n # model_config.dataset() should not be called again as it won't have the\\n # correct runtime information populated.\\n for inp in input_p:\\n if not isinstance(inp, base_input.BaseInputParams):\\n raise ValueError('Expecting BaseInputParams from datasets(), got: '\\n f'{inp.ToText()}')\\n inp.num_infeed_hosts = jax.process_count()\\n inp.infeed_host_index = jax.process_index()\\n train_input_p = [v for v in input_p if v.is_training]\\n if len(train_input_p) != 1:\\n raise ValueError(\\n f'Expecting exactly one training split. Got `{len(train_input_p)}`.')\\n train_input_p = train_input_p[0]\\n logging.info('train_input_p=%s', train_input_p.ToText())\\n eval_input_p = None\\n if eval_on_test:\\n eval_input_p = [v for v in input_p if not v.is_training]\\n\\n checkpoint_type = checkpoints.retrieve_checkpoint_type(\\n multi_host_checkpointing, maybe_use_persistence_checkpointing, task_p)\\n\\n checkpoint_manager = _create_checkpoint_manager(model_name, task_p,\\n job_log_dir, checkpoint_type,\\n checkpoint_todelete_subdir)\\n\\n if task_p.model.device_mesh is not None:\\n train_and_evaluate_spmd_model(task_p, train_input_p, job_log_dir,\\n checkpoint_manager, checkpoint_type,\\n restore_checkpoint_dir,\\n restore_checkpoint_step, eval_input_p)\\n else:\\n train_and_evaluate_pmap(task_p, train_input_p, job_log_dir,\\n checkpoint_manager, restore_checkpoint_dir,\\n restore_checkpoint_step, eval_input_p)\",\n \"def _setup_training(self, params, **kwargs):\\n model_params = params.permute_training_on_top().model\\n\\n model_kwargs = {**model_params.fixed, **model_params.variable}\\n\\n model = self.model_cls(**model_kwargs)\\n\\n training_params = params.permute_training_on_top().training\\n losses = training_params.nested_get(\\\"losses\\\")\\n optimizer_cls = training_params.nested_get(\\\"optimizer_cls\\\")\\n optimizer_params = training_params.nested_get(\\\"optimizer_params\\\")\\n train_metrics = training_params.nested_get(\\\"train_metrics\\\", {})\\n lr_scheduler_cls = training_params.nested_get(\\\"lr_sched_cls\\\", None)\\n lr_scheduler_params = training_params.nested_get(\\\"lr_sched_params\\\",\\n {})\\n val_metrics = training_params.nested_get(\\\"val_metrics\\\", {})\\n\\n # necessary for resuming training from a given path\\n save_path = kwargs.pop(\\\"save_path\\\", os.path.join(\\n self.save_path,\\n \\\"checkpoints\\\",\\n \\\"run_%02d\\\" % self._run))\\n\\n return self.trainer_cls(\\n network=model,\\n save_path=save_path,\\n losses=losses,\\n key_mapping=self.key_mapping,\\n optimizer_cls=optimizer_cls,\\n optimizer_params=optimizer_params,\\n train_metrics=train_metrics,\\n val_metrics=val_metrics,\\n lr_scheduler_cls=lr_scheduler_cls,\\n lr_scheduler_params=lr_scheduler_params,\\n optim_fn=self._optim_builder,\\n save_freq=self.checkpoint_freq,\\n **kwargs\\n )\",\n \"def create_or_load_model(model, model_dir, session, name):\\n latest_ckpt = tf.train.latest_checkpoint(model_dir)\\n if latest_ckpt:\\n start_time = time.time()\\n # It only takes a few seconds to initialize all variables.\\n session.run(tf.global_variables_initializer())\\n logging.info(\\n \\\"Initialize %s model with fresh parameters before loading variables \\\"\\n \\\"from the checkpoint, time %.2fs\\\", name,\\n time.time() - start_time)\\n model = load_model(model, latest_ckpt, session, name)\\n else:\\n start_time = time.time()\\n session.run(tf.global_variables_initializer())\\n session.run(tf.tables_initializer())\\n utils.print_out(\\\" created %s model with fresh parameters, time %.2fs\\\" %\\n (name, time.time() - start_time))\\n\\n global_step = model.global_step.eval(session=session)\\n return model, global_step\",\n \"def load_checkpoint(path: str, save_dir: str, cuda: bool = False, attention_viz: bool = False) -> nn.Module:\\r\\n # Load model and args\\r\\n state = torch.load(path, map_location=lambda storage, loc: storage)\\r\\n args, loaded_state_dict = state['args'], state['state_dict']\\r\\n\\r\\n # Update args with current args\\r\\n args.cuda = cuda\\r\\n args.attention_viz = attention_viz\\r\\n args.save_dir = save_dir\\r\\n\\r\\n model = build_model(args)\\r\\n model.load_state_dict(loaded_state_dict)\\r\\n\\r\\n if cuda:\\r\\n print('Moving model to cuda')\\r\\n model = model.cuda()\\r\\n\\r\\n return model\",\n \"def load_from_checkpoint(results_dir, load_fn, args):\\n ckpt_dir = os.path.join(results_dir, \\\"tb\\\", \\\"version_0\\\", \\\"checkpoints\\\")\\n files = os.listdir(ckpt_dir)\\n assert len(files) > 0, \\\"Checkpoint directory is empty\\\"\\n ckpt_path = os.path.join(ckpt_dir, files[-1])\\n model = load_fn(checkpoint_path=ckpt_path, args=args)\\n return model\",\n \"def load_checkpoint(model, model_name='model', validation_id=None):\\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\\n _load_model(model.module if type(model) is torch.nn.DataParallel else model, model_name, path=path, reload=True)\",\n \"def load_checkpoint(self, session, model_dir):\\n assert self.params.cp_load == True, (\\\"cp_load must be set to true to load a checkpoint\\\")\\n self.loader.restore(session, model_dir)\",\n \"def try_create_model_load_from_checkpoint_and_adjust(self) -> bool:\\n success = self.try_create_model_and_load_from_checkpoint()\\n self.create_summary_and_adjust_model_for_gpus()\\n return success\",\n \"def try_load_checkpoint_for_model(self) -> bool:\\n if self._model is None:\\n raise ValueError(\\\"Model must be created before it can be adjusted.\\\")\\n\\n if not self.checkpoint_path:\\n raise ValueError(\\\"No checkpoint provided\\\")\\n\\n if not self.checkpoint_path.is_file():\\n logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')\\n return False\\n\\n epoch = ModelAndInfo._load_checkpoint(model=self._model,\\n checkpoint_path=self.checkpoint_path,\\n key_in_state_dict=ModelAndInfo.MODEL_STATE_DICT_KEY,\\n use_gpu=self.config.use_gpu)\\n\\n logging.info(f\\\"Loaded model from checkpoint (epoch: {epoch})\\\")\\n self.checkpoint_epoch = epoch\\n return True\",\n \"def load_checkpoint(self, label):\\n model_dir = os.path.join(\\n config.results_dir, config.experiment_name, 'checkpoints')\\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\\n\\n print(\\\"Loading model from {}\\\".format(model_file))\\n model_dict = torch.load(model_file)\\n\\n self.use_cuda = model_dict['use_cuda']\\n if self.use_cuda:\\n self.net.cuda()\\n\\n self.net.load_state_dict(model_dict['net_state_dict'])\",\n \"def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\\n print(\\\"Load checkpoint from: {}\\\".format(path))\\n state_dict, optimizer_state = _load(path)\\n\\n model.load_dict(state_dict)\\n if not reset_optimizer and optimizer is not None:\\n if optimizer_state is not None:\\n print(\\\"[loading] Load optimizer state from {}\\\".format(path))\\n optimizer.load(optimizer_state)\\n\\n return model\",\n \"def load_checkpoints(args, model): \\n print('Loading the model checkpoints from iter {}...'.format(args.resume_iter))\\n checkpoint_path = os.path.join(config.checkpoint_path, args.model_type)\\n\\n gen_g_path = os.path.join(checkpoint_path, '{}-Gen_g.ckpt'.format(args.resume_iter))\\n gen_f_path = os.path.join(checkpoint_path, '{}-Gen_f.ckpt'.format(args.resume_iter))\\n model.gen_g.load_state_dict(torch.load(gen_g_path, map_location=lambda storage, loc: storage))\\n model.gen_f.load_state_dict(torch.load(gen_f_path, map_location=lambda storage, loc: storage))\\n\\n if args.train:\\n dis_c_path = os.path.join(checkpoint_path, '{}-Dis_c.ckpt'.format(args.resume_iter))\\n dis_t_path = os.path.join(checkpoint_path, '{}-Dis_t.ckpt'.format(args.resume_iter))\\n model.dis_c.load_state_dict(torch.load(dis_c_path, map_location=lambda storage, loc: storage))\\n model.dis_t.load_state_dict(torch.load(dis_t_path, map_location=lambda storage, loc: storage))\",\n \"def load_model (checkpoint_path, model, opt_fn=None, loss_fn=None, epoch=None):\\n\\n if not os.path.exists(checkpoint_path):\\n raise Exception (\\\"The {} does not exist!\\\".format(checkpoint_path))\\n\\n ckpt = torch.load(checkpoint_path)\\n model.load_state_dict(ckpt['model_state_dict'])\\n\\n if opt_fn is not None and loss_fn is not None:\\n opt_fn.load_state_dict(ckpt['optimizer_state_dict'])\\n epoch = ckpt['epoch']\\n loss_fn = ckpt['loss']\\n return model, opt_fn, loss_fn, epoch\\n else:\\n return model\",\n \"def train(model, infer_train, infer_val, load_checkpoint=None):\\n\\n global checkpoint_name\\n print('Initialising {}'.format(cfg['experiment_name']))\\n checkpoint_folder = 'checkpoints/{}/'.format(cfg['experiment_name'])\\n\\n if not os.path.exists(checkpoint_folder):\\n os.makedirs(checkpoint_folder)\\n\\n tb_folder = 'tb/{}/'.format(cfg['experiment_name'])\\n if not os.path.exists(tb_folder):\\n os.makedirs(tb_folder)\\n\\n writer = SummaryWriter(logdir=tb_folder, flush_secs=30)\\n optimiser = Adam(model.parameters(), lr=cfg['learning_rate'], weight_decay=cfg['weight_decay'])\\n\\n train_dataset = TweetDataset(dataset_type='train')\\n train_loader = DataLoader(train_dataset, batch_size=cfg['batch_size'], num_workers=cfg['workers'],\\n collate_fn=collate_function, shuffle=True, pin_memory=True)\\n\\n val_dataset = TweetDataset(dataset_type='val')\\n val_loader = DataLoader(val_dataset, batch_size=cfg['batch_size'], num_workers=cfg['workers'],\\n collate_fn=collate_function, shuffle=False, pin_memory=True)\\n\\n if load_checkpoint:\\n checkpoint = torch.load(load_checkpoint)\\n assert model.config == checkpoint['net_config'], \\\\\\n \\\"The provided checkpoint has a different configuration, loading is impossible\\\"\\n start_epoch = checkpoint['epoch'] + 1\\n epochs = cfg['epochs'] + start_epoch\\n step = checkpoint['step']\\n model.load_state_dict(checkpoint['model'])\\n optimiser.load_state_dict(checkpoint['optimiser'])\\n print(\\\"Loaded the checkpoint at {}\\\".format(load_checkpoint))\\n else:\\n start_epoch, step = 0, 0\\n epochs = cfg['epochs']\\n\\n init_loss = 0.\\n avg_loss = AverageMeter()\\n best_mae = 1e10\\n\\n print('Sanity val')\\n val(model, val_loader, writer, 0, infer_val)\\n model.train()\\n\\n print('Starting training')\\n for epoch in range(start_epoch, epochs):\\n loader_length = len(train_loader)\\n epoch_start = time.time()\\n\\n for batch_idx, batch in enumerate(train_loader):\\n optimiser.zero_grad()\\n\\n loss = infer_train(model, batch)\\n loss.backward()\\n\\n if epoch == 0 and batch_idx == 0:\\n init_loss = loss\\n\\n # logging\\n elapsed = time.time() - epoch_start\\n progress = batch_idx / loader_length\\n est = datetime.timedelta(seconds=int(elapsed / progress)) if progress > 0.001 else '-'\\n avg_loss.update(loss)\\n suffix = '\\\\tloss {:.4f}/{:.4f}\\\\tETA [{}/{}]'.format(avg_loss.avg, init_loss,\\n datetime.timedelta(seconds=int(elapsed)), est)\\n printProgressBar(batch_idx, loader_length, suffix=suffix,\\n prefix='Epoch [{}/{}]\\\\tStep [{}/{}]'.format(epoch, epochs - 1, batch_idx, loader_length))\\n\\n writer.add_scalar('Steps/train_loss', loss, step)\\n\\n # saving the model\\n if step % cfg['checkpoint_every'] == 0:\\n checkpoint_name = '{}/epoch_{}.pth'.format(checkpoint_folder, epoch)\\n torch.save({'model': model.state_dict(), 'epoch': epoch, 'batch_idx': batch_idx, 'step': step,\\n 'optimiser': optimiser.state_dict(), 'train_config': cfg, 'net_config': model.config,\\n 'dataset_config': DATASET_CONFIG},\\n checkpoint_name)\\n step += 1\\n optimiser.step()\\n\\n # validating\\n if step % cfg['val_every'] == 0:\\n mae = val(model, val_loader, writer, step, infer_val)\\n if mae < best_mae:\\n best_mae = mae\\n print('Best model with V{:.2f}'.format(best_mae))\\n torch.save({'model': model.state_dict(), 'epoch': epoch, 'batch_idx': batch_idx, 'step': step,\\n 'optimiser': optimiser.state_dict(), 'train_config': cfg, 'net_config': model.config,\\n 'dataset_config': DATASET_CONFIG},\\n '{}/best.pth'.format(checkpoint_folder))\\n model.train()\\n\\n # end of epoch\\n print('')\\n writer.add_scalar('Epochs/train_loss', avg_loss.avg, epoch)\\n avg_loss.reset()\\n checkpoint_name = '{}/epoch_{}.pth'.format(checkpoint_folder, epoch)\\n torch.save({'model': model.state_dict(), 'epoch': epoch, 'batch_idx': loader_length, 'step': step,\\n 'optimiser': optimiser.state_dict(), 'train_config': cfg, 'net_config': model.config,\\n 'dataset_config': DATASET_CONFIG},\\n checkpoint_name)\\n\\n # finished training\\n writer.close()\\n print('Training finished :)')\",\n \"def load_pretrained_model(self,model_dir):\\n rnn_params = json.load(open(os.path.join(model_dir,\\n \\\"./model.json\\\")))[\\\"rnn\\\"]\\n\\n logging.info(\\\"Loading model from: {}\\\".format(model_dir))\\n self.create_training_model(model_dir = model_dir,\\n **rnn_params)\\n #从目录中读取神经网络参数\\n self.set_model_from_file()\",\n \"def load_checkpoint(self, model, optimizers):\\n self.epoch = get_last_epoch(self.log_path)\\n\\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\\n model.load_state_dict(model_state_dict)\\n\\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\\n for opt_ind in range(len(optimizers)):\\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\\n\\n schedulers = load_sched(optimizers, self.epoch)\\n\\n return model, optimizers, schedulers\",\n \"def load_checkpoint(cfg, args):\\n checkpoint_iteration = args.checkpoint\\n bucket = connect_to_bucket(args.bucket)\\n # load actual checkpoint\\n if not os.path.isdir(cfg.OUTPUT_DIR):\\n os.mkdir(cfg.OUTPUT_DIR)\\n blob = bucket.blob(cfg.OUTPUT_DIR + \\\"/model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n blob.download_to_filename(cfg.OUTPUT_DIR + \\\"/model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n if args.resume:\\n # also write last checkpoint file for when --resume statement, model gets checkpoint name from this file\\n with open(cfg.OUTPUT_DIR + \\\"/last_checkpoint\\\", \\\"w\\\") as file:\\n file.write(\\\"model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n # return statement not clean, but useful for inference code\\n return checkpoint_iteration, bucket\",\n \"def load_model(config, batchmanager):\\n \\n # this function returns a dictionary mapping\\n # name of the task (string) --> number of classes in the task (int)\\n tasks = batchmanager.getTasksWithNClasses()\\n # this \\\"tasks\\\" object is used to initialize the model (with the right output layers)\\n model = MultiTaskBERT(device = config.device, tasks = tasks)\\n\\n if not config.untrained_baseline:\\n\\n # if we evaluate only, model MUST be loaded.\\n if config.k_shot_only:\\n try :\\n model.load_state_dict(torch.load(path_to_dicts(config), map_location = config.device))\\n except Exception:\\n print(f\\\"WARNING: the `--k_shot_only` flag was passed, but `{path_to_dicts(config)}` was NOT found!\\\")\\n raise Exception()\\n \\n # if we saved the state dictionary, load it.\\n elif config.resume:\\n try :\\n model.load_state_dict(torch.load(path_to_dicts(config), map_location = config.device))\\n except Exception:\\n print(f\\\"WARNING: the `--resume` flag was passed, but `{path_to_dicts(config)}` was NOT found!\\\")\\n else:\\n if os.path.exists(path_to_dicts(config)):\\n print(f\\\"WARNING: `--resume` flag was NOT passed, but `{path_to_dicts(config)}` was found!\\\") \\n\\n return model\",\n \"def train_model_by_config(\\n checkpoint: int,\\n config: lmp.config.BaseConfig,\\n dataset: lmp.dataset.BaseDataset,\\n model: lmp.model.BaseRNNModel,\\n optimizer: Union[\\n torch.optim.SGD,\\n torch.optim.Adam,\\n ],\\n tokenizer: lmp.tokenizer.BaseTokenizer,\\n):\\n # Create collate_fn for sampling.\\n collate_fn = lmp.dataset.BaseDataset.create_collate_fn(\\n tokenizer=tokenizer,\\n max_seq_len=config.max_seq_len\\n )\\n\\n # `torch` utility for sampling.\\n data_loader = torch.utils.data.DataLoader(\\n dataset,\\n batch_size=config.batch_size,\\n shuffle=True,\\n collate_fn=collate_fn\\n )\\n\\n train_model(\\n checkpoint=checkpoint,\\n checkpoint_step=config.checkpoint_step,\\n data_loader=data_loader,\\n device=config.device,\\n epoch=config.epoch,\\n experiment=config.experiment,\\n max_norm=config.max_norm,\\n model=model,\\n optimizer=optimizer,\\n vocab_size=tokenizer.vocab_size\\n )\",\n \"def load_model_from_checkpoint(file, device):\\r\\n\\r\\n if device == 'cuda':\\r\\n # Load all tensors onto GPU\\r\\n map_location = lambda storage, loc: storage.cuda()\\r\\n else:\\r\\n # Load all tensors onto CPU\\r\\n map_location = lambda storage, loc: storage\\r\\n\\r\\n # Assuming model was trained and checkpoint saved on Linux, but predict.py inference is executed using Windows.\\r\\n # Then, it is required to implement the following quick fix, because otherwise the exception is raised:\\r\\n # \\\"NotImplementedError: cannot instantiate 'PosixPath' on your system\\\"\\r\\n # Credits to https://stackoverflow.com/questions/57286486/i-cant-load-my-model-because-i-cant-put-a-posixpath\\r\\n if type(file) == pathlib.WindowsPath:\\r\\n tmp_PosixPath = pathlib.PosixPath\\r\\n pathlib.PosixPath = pathlib.WindowsPath\\r\\n\\r\\n parameters = torch.load(file, map_location=map_location)\\r\\n\\r\\n # Restore default\\r\\n if type(file) == pathlib.WindowsPath:\\r\\n pathlib.WindowsPath = pathlib.PosixPath\\r\\n pathlib.PosixPath = tmp_PosixPath\\r\\n\\r\\n model = train.create_model(parameters)\\r\\n\\r\\n model.class_to_idx = parameters.get('train_datasets_class_to_idx')\\r\\n model.load_state_dict(parameters.get('state_dict'), strict=False)\\r\\n\\r\\n return model, parameters\",\n \"def get_pretrain_model(pretrain_model, target_model, checkpoint='-1'):\\n if not os.path.isfile(os.path.join(pretrain_model, \\\"checkpoint\\\")):\\n sys.exit(\\\"[ERROR] Cannot find checkpoint in %s.\\\" % pretrain_model)\\n ckpt = tf.train.get_checkpoint_state(pretrain_model)\\n\\n model_checkpoint_path = ckpt.model_checkpoint_path\\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\\n\\n if not ckpt or not model_checkpoint_path:\\n sys.exit(\\\"[ERROR] Cannot read checkpoint %s.\\\" % os.path.join(pretrain_model, \\\"checkpoint\\\"))\\n\\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\\n steps = sorted(steps)\\n\\n if checkpoint == \\\"last\\\":\\n tf.logging.info(\\\"Load the last saved model.\\\")\\n checkpoint = steps[-1]\\n else:\\n checkpoint = int(checkpoint)\\n if checkpoint == -1:\\n tf.logging.info(\\\"Load the best model according to valid_loss\\\")\\n min_epoch = -1\\n min_loss = 1e10\\n with open(os.path.join(pretrain_model, \\\"valid_loss\\\")) as f:\\n for line in f.readlines():\\n epoch, loss, eer = line.split(\\\" \\\")\\n epoch = int(epoch)\\n loss = float(loss)\\n if loss < min_loss:\\n min_loss = loss\\n min_epoch = epoch\\n # Add 1 to min_epoch since epoch is 0-based\\n config_json = os.path.join(pretrain_model, \\\"config.json\\\")\\n params = Params(config_json)\\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\\n assert checkpoint in steps, \\\"The checkpoint %d not in the model directory\\\" % checkpoint\\n\\n pretrain_model_checkpoint_path = model_checkpoint_path.rsplit(\\\"-\\\", 1)[0] + \\\"-\\\" + str(checkpoint)\\n tf.logging.info(\\\"Copy the pre-trained model %s as the fine-tuned initialization\\\" % pretrain_model_checkpoint_path)\\n\\n import glob\\n for filename in glob.glob(pretrain_model_checkpoint_path + \\\"*\\\"):\\n bas = os.path.basename(filename).split(\\\"-\\\", 1)[0]\\n ext = os.path.basename(filename).rsplit(\\\".\\\", 1)[1]\\n shutil.copyfile(filename, os.path.join(target_model, bas + \\\"-0.\\\" + ext))\\n\\n with open(os.path.join(target_model, \\\"checkpoint\\\"), \\\"w\\\") as f:\\n f.write(\\\"model_checkpoint_path: \\\\\\\"%s\\\\\\\"\\\\n\\\" % os.path.join(target_model, os.path.basename(model_checkpoint_path).rsplit(\\\"-\\\", 1)[0] + \\\"-0\\\"))\\n f.write(\\\"all_model_checkpoint_paths: \\\\\\\"%s\\\\\\\"\\\\n\\\" % os.path.join(target_model, os.path.basename(model_checkpoint_path).rsplit(\\\"-\\\", 1)[0] + \\\"-0\\\"))\\n return\",\n \"def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\\n self.model.load_state_dict(checkpoint[\\\"model_state_dict\\\"])\\n self.optimizer.load_state_dict(checkpoint[\\\"optimizer_state_dict\\\"])\\n return self\",\n \"def checkpoint_load(checkpoint_path, gpu):\\n model_info = torch.load(checkpoint_path)\\n model = models.vgg19(pretrained=True)\\n for param in model.parameters():\\n param.requires_grad = False\\n \\n model.class_to_idx = model_info['class_to_idx']\\n\\n model = classifier(model)\\n model.load_state_dict(model_info[\\\"model_state_dict\\\"])\\n return model, model.class_to_idx\",\n \"def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\\n print(\\\"Loading checkpoint: {}\\\".format(checkpoint_path))\\n state = torch.load(checkpoint_path)\\n self.model.load_state_dict(state['state_dict'])\\n self.optimizer.load_state_dict(state['optim_dict'])\\n\\n if continue_from_epoch:\\n self.epoch = state['epoch']\",\n \"def create_reference_model(self, config, tmp_path_factory: pytest.TempPathFactory, *args):\\n config = copy.deepcopy(config) # ensure the reference model is not passed to tests\\n\\n save_folder = tmp_path_factory.mktemp('{device}-{precision}'.format(**config))\\n config.update({'save_interval': '1ep', 'save_folder': str(save_folder), 'save_filename': 'ep{epoch}.pt'})\\n\\n trainer = Trainer(**config)\\n trainer.fit()\\n\\n self.reference_model = trainer.state.model\\n self.reference_folder = save_folder\",\n \"def create_model( session, batch_size ):\\n model = linear_model.LinearModel(\\n FLAGS.linear_size,\\n FLAGS.num_layers,\\n FLAGS.residual,\\n FLAGS.batch_norm,\\n FLAGS.max_norm,\\n batch_size,\\n FLAGS.learning_rate,\\n FLAGS.origin_bc,\\n summaries_dir,\\n dtype=tf.float16 if FLAGS.use_fp16 else tf.float32)\\n\\n if FLAGS.load <= 0:\\n # Create a new model from scratch\\n print(\\\"Creating model with fresh parameters.\\\")\\n session.run( tf.global_variables_initializer() )\\n return model\\n\\n # Load a previously saved model\\n ckpt = tf.train.get_checkpoint_state( train_dir, latest_filename=\\\"checkpoint\\\")\\n print( \\\"train_dir\\\", train_dir )\\n\\n if ckpt and ckpt.model_checkpoint_path:\\n # Check if the specific cpixels = pixels / pixels[2,:]heckpoint exists\\n if FLAGS.load > 0:\\n if os.path.isfile(os.path.join(train_dir,\\\"checkpoint-{0}.index\\\".format(FLAGS.load))):\\n ckpt_name = os.path.join( os.path.join(train_dir,\\\"checkpoint-{0}\\\".format(FLAGS.load)) )\\n else:\\n raise ValueError(\\\"Asked to load checkpoint {0}, but it does not seem to exist\\\".format(FLAGS.load))\\n else:\\n ckpt_name = os.path.basename( ckpt.model_checkpoint_path )\\n\\n print(\\\"Loading model {0}\\\".format( ckpt_name ))\\n model.saver.restore( session, ckpt.model_checkpoint_path )\\n return model\\n else:\\n print(\\\"Could not find checkpoint. Aborting.\\\")\\n raise( ValueError, \\\"Checkpoint {0} does not seem to exist\\\".format( ckpt.model_checkpoint_path ) )\\n\\n return model\",\n \"def main(cfg, logger):\\n\\n # Initialize parameters\\n model_selection_metric = cfg['train']['model_selection_metric']\\n\\n if cfg['train']['model_selection_mode'] == 'maximize':\\n model_selection_sign = 1\\n elif cfg['train']['model_selection_mode'] == 'minimize':\\n model_selection_sign = -1\\n else:\\n raise ValueError(\\n 'model_selection_mode must be either maximize or minimize.')\\n\\n # Get data loader\\n train_loader = make_data_loader(cfg, phase='train')\\n val_loader = make_data_loader(cfg, phase='val')\\n\\n # Set up tensorboard logger\\n tboard_logger = SummaryWriter(os.path.join(cfg['misc']['log_dir'], 'logs'))\\n\\n # Get model\\n model = config.get_model(cfg)\\n\\n # Get optimizer and trainer\\n optimizer = getattr(optim, cfg['optimizer']['alg'])(model.parameters(), lr=cfg['optimizer']['learning_rate'],\\n weight_decay=cfg['optimizer']['weight_decay'])\\n\\n trainer = config.get_trainer(cfg, model, optimizer, tboard_logger)\\n\\n # Load pre-trained model if existing\\n kwargs = {\\n 'model': model,\\n 'optimizer': optimizer,\\n }\\n\\n checkpoint_io = CheckpointIO(cfg['misc']['log_dir'], initialize_from=cfg['model']['init_from'],\\n initialization_file_name=cfg['model']['init_file_name'], **kwargs)\\n\\n try:\\n load_dict = checkpoint_io.load('model.pt')\\n except FileExistsError:\\n load_dict = dict()\\n\\n epoch_it = load_dict.get('epoch_it', -1)\\n it = load_dict.get('it', -1)\\n\\n metric_val_best = load_dict.get(\\n 'loss_val_best', -model_selection_sign * np.inf)\\n\\n if metric_val_best == np.inf or metric_val_best == -np.inf:\\n metric_val_best = -model_selection_sign * np.inf\\n\\n logger.info('Current best validation metric ({}): {:.5f}'.format(\\n model_selection_metric, metric_val_best))\\n\\n # Training parameters\\n stat_interval = cfg['train']['stat_interval']\\n stat_interval = stat_interval if stat_interval > 0 else abs(\\n stat_interval * len(train_loader))\\n\\n chkpt_interval = cfg['train']['chkpt_interval']\\n chkpt_interval = chkpt_interval if chkpt_interval > 0 else abs(\\n chkpt_interval * len(train_loader))\\n\\n val_interval = cfg['train']['val_interval']\\n val_interval = val_interval if val_interval > 0 else abs(\\n val_interval * len(train_loader))\\n\\n # Print model parameters and model graph\\n nparameters = sum(p.numel() for p in model.parameters())\\n # print(model)\\n logger.info('Total number of parameters: {}'.format(nparameters))\\n\\n # Training loop\\n while epoch_it < cfg['train']['max_epoch']:\\n epoch_it += 1\\n\\n for batch in train_loader:\\n it += 1\\n loss = trainer.train_step(batch, it)\\n tboard_logger.add_scalar('train/loss', loss, it)\\n\\n # Print output\\n if stat_interval != 0 and (it % stat_interval) == 0 and it != 0:\\n logger.info('[Epoch {}] it={}, loss={:.4f}'.format(\\n epoch_it, it, loss))\\n\\n # Save checkpoint\\n if (chkpt_interval != 0 and (it % chkpt_interval) == 0) and it != 0:\\n logger.info('Saving checkpoint')\\n checkpoint_io.save('model.pt', epoch_it=epoch_it, it=it,\\n loss_val_best=metric_val_best)\\n\\n # Run validation\\n if val_interval != 0 and (it % val_interval) == 0 and it != 0:\\n eval_dict = trainer.evaluate(val_loader, it)\\n\\n metric_val = eval_dict[model_selection_metric]\\n logger.info('Validation metric ({}): {:.4f}'.format(\\n model_selection_metric, metric_val))\\n\\n for k, v in eval_dict.items():\\n tboard_logger.add_scalar('val/{}'.format(k), v, it)\\n\\n if model_selection_sign * (metric_val - metric_val_best) > 0:\\n metric_val_best = metric_val\\n logger.info(\\n 'New best model (loss {:.4f})'.format(metric_val_best))\\n checkpoint_io.save('model_best.pt', epoch_it=epoch_it, it=it,\\n loss_val_best=metric_val_best)\\n\\n # Quit after the maximum number of epochs is reached\\n logger.info('Training completed after {} Epochs ({} it) with best val metric ({})={}'.format(\\n epoch_it, it, model_selection_metric, metric_val_best))\",\n \"def load_checkpoint(self, checkpoint_dir):\\r\\n\\r\\n if not os.path.exists(checkpoint_dir):\\r\\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\\r\\n\\r\\n path = os.path.join(checkpoint_dir, 'model.pt')\\r\\n self.model.load_state_dict(torch.load(path, self.device))\\r\\n self.update()\",\n \"def load_checkpoint(self, model):\\n print(f\\\"load model {self.save_model_path}\\\")\\n model.load_state_dict(torch.load(self.save_model_path))\",\n \"def load_ckp(checkpoint_fpath, model, optimizer, device):\\n\\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\\n model.load_state_dict(checkpoint['state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n valid_acc = checkpoint['valid_acc'] \\n return model, optimizer, checkpoint['epoch'], valid_acc\",\n \"def _init_model(\\n self,\\n cfg: ConfigType,\\n weights: Optional[str],\\n device: str = 'cpu',\\n ) -> nn.Module:\\n checkpoint: Optional[dict] = None\\n if weights is not None:\\n checkpoint = _load_checkpoint(weights, map_location='cpu')\\n\\n if not cfg:\\n assert checkpoint is not None\\n try:\\n # Prefer to get config from `message_hub` since `message_hub`\\n # is a more stable module to store all runtime information.\\n # However, the early version of MMEngine will not save config\\n # in `message_hub`, so we will try to load config from `meta`.\\n cfg_string = checkpoint['message_hub']['runtime_info']['cfg']\\n except KeyError:\\n assert 'meta' in checkpoint, (\\n 'If model(config) is not provided, the checkpoint must'\\n 'contain the config string in `meta` or `message_hub`, '\\n 'but both `meta` and `message_hub` are not found in the '\\n 'checkpoint.')\\n meta = checkpoint['meta']\\n if 'cfg' in meta:\\n cfg_string = meta['cfg']\\n else:\\n raise ValueError(\\n 'Cannot find the config in the checkpoint.')\\n cfg.update(\\n Config.fromstring(cfg_string, file_format='.py')._cfg_dict)\\n\\n # Delete the `pretrained` field to prevent model from loading the\\n # the pretrained weights unnecessarily.\\n if cfg.model.get('pretrained') is not None:\\n del cfg.model.pretrained\\n\\n model = MODELS.build(cfg.model)\\n model.cfg = cfg\\n self._load_weights_to_model(model, checkpoint, cfg)\\n model.to(device)\\n model.eval()\\n return model\",\n \"def get_checkpoint(model, checkpoint='-1'):\\n if not os.path.isfile(os.path.join(model, \\\"checkpoint\\\")):\\n sys.exit(\\\"[ERROR] Cannot find checkpoint in %s.\\\" % model)\\n ckpt = tf.train.get_checkpoint_state(model)\\n\\n model_checkpoint_path = ckpt.model_checkpoint_path\\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\\n\\n if not ckpt or not model_checkpoint_path:\\n sys.exit(\\\"[ERROR] Cannot read checkpoint %s.\\\" % os.path.join(model, \\\"checkpoint\\\"))\\n\\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\\n steps = sorted(steps)\\n if checkpoint == \\\"last\\\":\\n tf.logging.info(\\\"Load the last saved model.\\\")\\n checkpoint = steps[-1]\\n else:\\n checkpoint = int(checkpoint)\\n if checkpoint == -1:\\n tf.logging.info(\\\"Load the best model according to valid_loss\\\")\\n min_epoch = -1\\n min_loss = 1e10\\n with open(os.path.join(model, \\\"valid_loss\\\")) as f:\\n for line in f.readlines():\\n epoch, loss, eer = line.split(\\\" \\\")\\n epoch = int(epoch)\\n loss = float(loss)\\n if loss < min_loss:\\n min_loss = loss\\n min_epoch = epoch\\n # Add 1 to min_epoch since epoch is 0-based\\n config_json = os.path.join(model, \\\"config.json\\\")\\n params = Params(config_json)\\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\\n tf.logging.info(\\\"The checkpoint is %d\\\" % checkpoint)\\n assert checkpoint in steps, \\\"The checkpoint %d not in the model directory\\\" % checkpoint\\n\\n model_checkpoint_path = model_checkpoint_path.rsplit(\\\"-\\\", 1)[0] + \\\"-\\\" + str(checkpoint)\\n model_checkpoint_path = os.path.join(model, os.path.basename(model_checkpoint_path))\\n\\n with open(os.path.join(model, \\\"checkpoint\\\"), \\\"w\\\") as f:\\n f.write(\\\"model_checkpoint_path: \\\\\\\"%s\\\\\\\"\\\\n\\\" % model_checkpoint_path)\\n for checkpoint in all_model_checkpoint_paths:\\n checkpoint_new = os.path.join(model, os.path.basename(checkpoint))\\n f.write(\\\"all_model_checkpoint_paths: \\\\\\\"%s\\\\\\\"\\\\n\\\" % checkpoint_new)\\n return model_checkpoint_path\",\n \"def load_pretrained_model(self, model_path):\\n # My eyes and my heart both hurt when writing this method\\n\\n # Only care about layer_types that have trainable parameters\\n ltypes = ['BNData', 'ConvolutionData', 'HoleConvolutionData']\\n\\n def _get_layer_params(layer, ltype):\\n\\n if ltype == 'BNData': \\n n_channels = layer.blobs[0].shape.dim[1]\\n gamma = np.array(layer.blobs[0].data).reshape(n_channels)\\n beta = np.array(layer.blobs[1].data).reshape(n_channels)\\n mean = np.array(layer.blobs[2].data).reshape(n_channels)\\n var = np.array(layer.blobs[3].data).reshape(n_channels)\\n return [mean, var, gamma, beta]\\n\\n elif ltype in ['ConvolutionData', 'HoleConvolutionData']:\\n is_bias = layer.convolution_param.bias_term\\n shape = [int(d) for d in layer.blobs[0].shape.dim]\\n weights = np.array(layer.blobs[0].data).reshape(shape)\\n bias = []\\n if is_bias:\\n bias = np.array(layer.blobs[1].data).reshape(shape[0])\\n return [weights, bias]\\n \\n elif ltype == 'InnerProduct':\\n raise Exception(\\\"Fully connected layers {}, not supported\\\".format(ltype))\\n\\n else:\\n raise Exception(\\\"Unkown layer type {}\\\".format(ltype))\\n\\n\\n net = caffe_pb2.NetParameter()\\n with open(model_path, 'rb') as model_file:\\n net.MergeFromString(model_file.read())\\n\\n # dict formatted as -> key:<layer_name> :: value:<layer_type>\\n layer_types = {}\\n # dict formatted as -> key:<layer_name> :: value:[<list_of_params>]\\n layer_params = {}\\n\\n for l in net.layer:\\n lname = l.name\\n ltype = l.type\\n if ltype in ltypes:\\n print(\\\"Processing layer {}\\\".format(lname))\\n layer_types[lname] = ltype\\n layer_params[lname] = _get_layer_params(l, ltype)\\n\\n # Set affine=False for all batchnorm modules\\n def _no_affine_bn(module=None):\\n if isinstance(module, nn.BatchNorm2d):\\n module.affine = False\\n\\n if len([m for m in module.children()]) > 0:\\n for child in module.children():\\n _no_affine_bn(child)\\n\\n #_no_affine_bn(self)\\n\\n\\n def _transfer_conv(layer_name, module):\\n weights, bias = layer_params[layer_name]\\n w_shape = np.array(module.weight.size())\\n \\n np.testing.assert_array_equal(weights.shape, w_shape)\\n print(\\\"CONV: Original {} and trans weights {}\\\".format(w_shape,\\n weights.shape))\\n module.weight.data = torch.from_numpy(weights)\\n\\n if len(bias) != 0:\\n b_shape = np.array(module.bias.size())\\n np.testing.assert_array_equal(bias.shape, b_shape)\\n print(\\\"CONV: Original {} and trans bias {}\\\".format(b_shape,\\n bias.shape))\\n module.bias.data = torch.from_numpy(bias)\\n\\n\\n def _transfer_conv_bn(conv_layer_name, mother_module):\\n conv_module = mother_module[0]\\n bn_module = mother_module[1]\\n \\n _transfer_conv(conv_layer_name, conv_module)\\n \\n mean, var, gamma, beta = layer_params[conv_layer_name+'/bn']\\n print(\\\"BN: Original {} and trans weights {}\\\".format(bn_module.running_mean.size(),\\n mean.shape))\\n bn_module.running_mean = torch.from_numpy(mean)\\n bn_module.running_var = torch.from_numpy(var)\\n bn_module.weight.data = torch.from_numpy(gamma)\\n bn_module.bias.data = torch.from_numpy(beta)\\n\\n\\n def _transfer_residual(prefix, block):\\n block_module, n_layers = block[0], block[1]\\n\\n bottleneck = block_module.layers[0]\\n bottleneck_conv_bn_dic = {prefix + '_1_1x1_reduce': bottleneck.cbr1.cbr_unit,\\n prefix + '_1_3x3': bottleneck.cbr2.cbr_unit,\\n prefix + '_1_1x1_proj': bottleneck.cb4.cb_unit,\\n prefix + '_1_1x1_increase': bottleneck.cb3.cb_unit,}\\n\\n for k, v in bottleneck_conv_bn_dic.items():\\n _transfer_conv_bn(k, v)\\n\\n for layer_idx in range(2, n_layers+1):\\n residual_layer = block_module.layers[layer_idx-1]\\n residual_conv_bn_dic = {'_'.join(map(str, [prefix, layer_idx, '1x1_reduce'])): residual_layer.cbr1.cbr_unit,\\n '_'.join(map(str, [prefix, layer_idx, '3x3'])): residual_layer.cbr2.cbr_unit,\\n '_'.join(map(str, [prefix, layer_idx, '1x1_increase'])): residual_layer.cb3.cb_unit,} \\n \\n for k, v in residual_conv_bn_dic.items():\\n _transfer_conv_bn(k, v)\\n\\n\\n convbn_layer_mapping = {'conv1_1_3x3_s2': self.convbnrelu1_1.cbr_unit,\\n 'conv1_2_3x3': self.convbnrelu1_2.cbr_unit,\\n 'conv1_3_3x3': self.convbnrelu1_3.cbr_unit,\\n 'conv5_3_pool6_conv': self.pyramid_pooling.paths[0].cbr_unit, \\n 'conv5_3_pool3_conv': self.pyramid_pooling.paths[1].cbr_unit,\\n 'conv5_3_pool2_conv': self.pyramid_pooling.paths[2].cbr_unit,\\n 'conv5_3_pool1_conv': self.pyramid_pooling.paths[3].cbr_unit,\\n 'conv5_4': self.cbr_final.cbr_unit,}\\n\\n residual_layers = {'conv2': [self.res_block2, self.block_config[0]],\\n 'conv3': [self.res_block3, self.block_config[1]],\\n 'conv4': [self.res_block4, self.block_config[2]],\\n 'conv5': [self.res_block5, self.block_config[3]],}\\n\\n # Transfer weights for all non-residual conv+bn layers\\n for k, v in convbn_layer_mapping.items():\\n _transfer_conv_bn(k, v)\\n\\n # Transfer weights for final non-bn conv layer\\n _transfer_conv('conv6', self.classification)\\n\\n # Transfer weights for all residual layers\\n for k, v in residual_layers.items():\\n _transfer_residual(k, v)\",\n \"def load(self, checkpoint_dir=None):\\n\\n if checkpoint_dir is None:\\n checkpoint_dir = FLAGS.checkpoint_dir\\n\\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\\n\\n return self.load_from_path(checkpoint_dir)\",\n \"def load_training_checkpoint(args, model, PATH, ckpt_id):\\r\\n logger = args.logger\\r\\n _, checkpoint_state_dict = model.network.load_checkpoint(PATH, ckpt_id)\\r\\n epoch = checkpoint_state_dict['epoch']\\r\\n last_global_step = checkpoint_state_dict['last_global_step']\\r\\n last_global_data_samples = checkpoint_state_dict[\\r\\n 'last_global_data_samples']\\r\\n del checkpoint_state_dict\\r\\n return (epoch, last_global_step, last_global_data_samples)\",\n \"def load(loadname, checkpoint=None):\\n ckpt_dir = \\\"./models/tf_ckpt_\\\" + loadname + \\\"/\\\"\\n if checkpoint is not None:\\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\\n status.assert_consumed()\\n print(\\\"Loaded checkpoint\\\")\\n else:\\n print(\\\"Not Loading any checkpoint\\\")\\n print(\\\"Starting training from initial configuration\\\")\",\n \"def load_params(self, params):\\n params.cp_latest_filename = \\\"latest_checkpoint_v\\\"+params.version\\n params.cp_load_latest_filename = \\\"latest_checkpoint_v\\\"+params.cp_load_ver\\n params.cp_load_dir = params.out_dir + params.cp_load_name+ \\\"/checkpoints/\\\"\\n if not hasattr(params, \\\"model_out_dir\\\"):\\n params.model_out_dir = params.out_dir + params.model_name\\n params.cp_save_dir = params.model_out_dir + \\\"/checkpoints/\\\"\\n params.log_dir = params.model_out_dir + \\\"/logfiles/\\\"\\n params.save_dir = params.model_out_dir + \\\"/savefiles/\\\"\\n params.disp_dir = params.model_out_dir + \\\"/vis/\\\"\\n params.num_pixels = int(np.prod(params.data_shape))\\n self.params = params\\n self.params_loaded = True\",\n \"def checkpoint_model(PATH, ckpt_id, model, epoch, last_global_step,\\r\\n last_global_data_samples, **kwargs):\\r\\n checkpoint_state_dict = {\\r\\n 'epoch': epoch,\\r\\n 'last_global_step': last_global_step,\\r\\n 'last_global_data_samples': last_global_data_samples\\r\\n }\\r\\n # Add extra kwargs too\\r\\n checkpoint_state_dict.update(kwargs)\\r\\n\\r\\n success = model.network.save_checkpoint(PATH, ckpt_id,\\r\\n checkpoint_state_dict)\\r\\n status_msg = 'checkpointing: PATH={}, ckpt_id={}'.format(PATH, ckpt_id)\\r\\n if success:\\r\\n logging.info(f\\\"Success {status_msg}\\\")\\r\\n else:\\r\\n logging.warning(f\\\"Failure {status_msg}\\\")\\r\\n return\",\n \"def load_model(self, model_path):\\n # Check the model file exists\\n if not os.path.isfile(model_path):\\n raise ValueError(f\\\"The model file `{model_path}` is not exists or broken!\\\")\\n\\n checkpoint = torch.load(model_path)\\n self.model_type = checkpoint['model_type']\\n self.label2idx = checkpoint['label2idx']\\n self.idx2label = checkpoint['idx2label']\\n self.model.load_state_dict(checkpoint['model_state_dict'])\\n self.model.to(self.device)\",\n \"def try_create_model_and_load_from_checkpoint(self) -> bool:\\n self.create_model()\\n if self.checkpoint_path:\\n # Load the stored model. If there is no checkpoint present, return immediately.\\n return self.try_load_checkpoint_for_model()\\n return True\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint)\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load_model(self):\\n if os.stat('code/lr-model.pt').st_size == 0:\\n return\\n params = torch.load('code/lr-model.pt')\\n self.set_params(params)\",\n \"def _load_checkpoint_to_net(config, network):\\n if config.existed_ckpt:\\n if config.existed_ckpt.endswith(\\\".npz\\\"):\\n weights = np.load(config.existed_ckpt)\\n else:\\n weights = load_checkpoint(config.existed_ckpt)\\n for param in network.trainable_params():\\n weights_name = param.name\\n if weights_name not in weights:\\n raise ValueError(f\\\"Param {weights_name} is not found in ckpt file.\\\")\\n\\n if isinstance(weights[weights_name], Parameter):\\n param.set_data(weights[weights_name].data)\\n elif isinstance(weights[weights_name], Tensor):\\n param.set_data(Tensor(weights[weights_name].asnumpy(), config.dtype))\\n elif isinstance(weights[weights_name], np.ndarray):\\n param.set_data(Tensor(weights[weights_name], config.dtype))\\n else:\\n param.set_data(weights[weights_name])\\n else:\\n for param in network.trainable_params():\\n name = param.name\\n value = param.data\\n if isinstance(value, Tensor):\\n if name.endswith(\\\".gamma\\\"):\\n param.set_data(one_weight(value.asnumpy().shape))\\n elif name.endswith(\\\".beta\\\") or name.endswith(\\\".bias\\\"):\\n if param.data.dtype == \\\"Float32\\\":\\n param.set_data((weight_variable(value.asnumpy().shape).astype(np.float32)))\\n elif param.data.dtype == \\\"Float16\\\":\\n param.set_data((weight_variable(value.asnumpy().shape).astype(np.float16)))\\n else:\\n if param.data.dtype == \\\"Float32\\\":\\n param.set_data(Tensor(weight_variable(value.asnumpy().shape).astype(np.float32)))\\n elif param.data.dtype == \\\"Float16\\\":\\n param.set_data(Tensor(weight_variable(value.asnumpy().shape).astype(np.float16)))\",\n \"def build_graph_from_config(self, model_config, track_config, checkpoint_path):\\n self.build_model()\\n \\n ema = tf.train.ExponentialMovingAverage(0)\\n variables_to_restore = ema.variables_to_restore(moving_avg_variables=[])\\n\\n # Filter out State variables\\n variables_to_restore_filterd = {}\\n for key, value in variables_to_restore.items():\\n if key.split('/')[1] != 'State':\\n if \\\"alex_branch\\\" not in key:\\n if \\\"vggf_branch\\\" not in key:\\n variables_to_restore_filterd[key] = value\\n \\n saver = tf.train.Saver(variables_to_restore_filterd)\\n \\n\\n if osp.isdir(checkpoint_path):\\n #checkpoint_path = tf.train.latest_checkpoint(checkpoint_path)\\n if not checkpoint_path:\\n raise ValueError(\\\"No checkpoint file found in: {}\\\".format(checkpoint_path))\\n\\n def _restore_fn(sess):\\n logging.info(\\\"Loading model from checkpoint: %s\\\", checkpoint_path)\\n saver.restore(sess, checkpoint_path)\\n logging.info(\\\"Successfully loaded checkpoint: %s\\\", os.path.basename(checkpoint_path))\\n logging.info(\\\"Restore CANet...\\\")\\n\\n return _restore_fn\",\n \"def load_checkpoint(self, checkpoint_path: Union[str, Path]) -> Dict[str, Any]:\\n # TODO: move to CheckpointIO\\n torch.cuda.empty_cache()\\n checkpoint_path = inject_model_parallel_rank(checkpoint_path)\\n return self.checkpoint_io.load_checkpoint(checkpoint_path)\",\n \"def train_model(self):\\n self.logger.info('Loading the data...')\\n train_data = self.load_data(split=\\\"train\\\")\\n dev_data = self.load_data(split=\\\"dev\\\")\\n self.config.best_model = os.path.join(self.config.output_dir,\\\"best_model\\\")\\n self.logger.info('Training the model, outputdir=%s...,best_model=%s' % (self.config.output_dir,self.config.best_model))\\n\\n train_params = {\\n \\\"overwrite_output_dir\\\" : True,\\n \\\"reprocess_input_data\\\": True,\\n \\\"learning_rate\\\" : self.config.learning_rate,\\n \\\"num_train_epochs\\\" : self.config.num_train_epochs,\\n \\\"train_batch_size\\\" : self.config.train_batch_size,\\n \\\"eval_batch_size\\\" : self.config.eval_batch_size,\\n \\\"gradient_accumulation_steps\\\": self.config.gradient_accumulation_steps,\\n \\\"use_early_stopping\\\" : self.config.early_stopping,\\n \\\"fp16\\\" : False,\\n \\\"classification_report\\\" : True,\\n \\\"evaluate_during_training\\\" : True,\\n \\\"evaluate_during_training_verbose\\\" : True,\\n \\\"best_model_dir\\\": self.config.best_model,\\n \\\"save_model_every_epoch\\\" : self.config.save_model_every_epoch,\\n \\\"save_steps\\\" : self.config.save_steps,\\n \\\"save_optimizer_and_scheduler\\\" : self.config.save_optimizer_and_scheduler,\\n \\\"save_best_model\\\": True,\\n }\\n\\n ## train the model \\n self.model.train_model(\\n train_data,\\n eval_data=dev_data,\\n output_dir=self.config.output_dir,\\n show_running_loss=False,\\n args=train_params,\\n )\\n\\n ## backing up the config and create pointer to best model \\n with open(os.path.join(self.config.best_model,\\\"trainer_config.json\\\"),'w') as mconfig:\\n mconfig.write(json.dumps(self.config.__dict__))\\n self.config.existing_model = self.config.best_model\",\n \"def train(self, resume_from_checkpoint: Optional[Union[str, bool]] = None,\\n trial: Union[\\\"optuna.Trial\\\", Dict[str, Any]] = None, ignore_keys_for_eval: Optional[List[str]] = None, **kwargs):\\n\\n # memory metrics - must set up as early as possible\\n self._memory_tracker.start()\\n\\n args = self.args\\n\\n self.is_in_train = True\\n\\n # do_train is not a reliable argument, as it might not be set and .train() still called, so\\n # the following is a workaround:\\n if args.fp16_full_eval and not args.do_train:\\n self.model = self.model.to(args.device)\\n\\n if \\\"model_path\\\" in kwargs:\\n resume_from_checkpoint = kwargs.pop(\\\"model_path\\\")\\n if len(kwargs) > 0:\\n raise TypeError(f\\\"train() received got unexpected keyword arguments: {', '.join(list(kwargs.keys()))}.\\\")\\n\\n # This might change the seed so needs to run first.\\n self._hp_search_setup(trial)\\n\\n # Model re-init\\n model_reloaded = False\\n if self.model_init is not None:\\n # Seed must be set before instantiating the model when using model_init.\\n set_seed(args.seed)\\n self.model = self.call_model_init(trial)\\n model_reloaded = True\\n\\n # Reinitializes optimizer and scheduler\\n self.optimizer, self.lr_scheduler = None, None\\n\\n # Load potential model checkpoint\\n if isinstance(resume_from_checkpoint, bool) and resume_from_checkpoint:\\n resume_from_checkpoint = get_last_checkpoint(args.output_dir)\\n if resume_from_checkpoint is None:\\n raise ValueError(f\\\"No valid checkpoint found in output directory ({args.output_dir})\\\")\\n\\n # If model was re-initialized, put it on the right device and update self.model_wrapped\\n if model_reloaded:\\n if self.place_model_on_device:\\n self.model = self.model.to(args.device)\\n self.model_wrapped = self.model\\n\\n # Keeping track whether we can len() on the dataset or not\\n train_dataset_is_sized = isinstance(self.train_dataset, collections.abc.Sized)\\n\\n # Data loader and number of training steps\\n train_dataloader = self.get_train_dataloader()\\n\\n # Setting up training control variables:\\n # number of training epochs: num_train_epochs\\n # number of training steps per epoch: num_update_steps_per_epoch\\n # total number of training steps to execute: max_steps\\n if train_dataset_is_sized:\\n num_update_steps_per_epoch = len(train_dataloader) // args.gradient_accumulation_steps\\n num_update_steps_per_epoch = max(num_update_steps_per_epoch, 1)\\n if args.max_steps > 0:\\n max_steps = args.max_steps\\n num_train_epochs = args.max_steps // num_update_steps_per_epoch + int(\\n args.max_steps % num_update_steps_per_epoch > 0\\n )\\n else:\\n max_steps = math.ceil(args.num_train_epochs * num_update_steps_per_epoch)\\n num_train_epochs = math.ceil(args.num_train_epochs)\\n else:\\n # see __init__. max_steps is set when the dataset has no __len__\\n max_steps = args.max_steps\\n num_train_epochs = int(args.num_train_epochs)\\n num_update_steps_per_epoch = max_steps\\n\\n self.create_optimizer_and_scheduler(num_training_steps=max_steps)\\n\\n self.state = TrainerState()\\n self.state.is_hyper_param_search = trial is not None\\n\\n model = self._wrap_model(self.model_wrapped)\\n\\n # for the rest of this function `model` is the outside model, whether it was wrapped or not\\n if model is not self.model:\\n self.model_wrapped = model\\n\\n # Check if saved optimizer or scheduler states exist\\n self._load_optimizer_and_scheduler(resume_from_checkpoint)\\n\\n # Train!\\n world_size = 1 # number of processes in parallel\\n\\n total_train_batch_size = args.train_batch_size * args.gradient_accumulation_steps * world_size\\n num_examples = (self.num_examples(train_dataloader) if train_dataset_is_sized else total_train_batch_size * args.max_steps)\\n\\n logger.info(\\\"***** Running training *****\\\")\\n logger.info(f\\\" Num examples = {num_examples}\\\")\\n logger.info(f\\\" Num Epochs = {num_train_epochs}\\\")\\n logger.info(f\\\" Instantaneous batch size per device = {args.per_device_train_batch_size}\\\")\\n logger.info(f\\\" Total train batch size (w. parallel, distributed & accumulation) = {total_train_batch_size}\\\")\\n logger.info(f\\\" Gradient Accumulation steps = {args.gradient_accumulation_steps}\\\")\\n logger.info(f\\\" Total optimization steps = {max_steps}\\\")\\n\\n self.state.epoch = 0\\n start_time = time.time()\\n epochs_trained = 0\\n steps_trained_in_current_epoch = 0\\n steps_trained_progress_bar = None\\n\\n # Check if continuing training from a checkpoint\\n if resume_from_checkpoint is not None and os.path.isfile(os.path.join(resume_from_checkpoint, \\\"trainer_state.json\\\")):\\n self.state = TrainerState.load_from_json(os.path.join(resume_from_checkpoint, \\\"trainer_state.json\\\"))\\n epochs_trained = self.state.global_step // num_update_steps_per_epoch\\n if not args.ignore_data_skip:\\n steps_trained_in_current_epoch = self.state.global_step % (num_update_steps_per_epoch)\\n steps_trained_in_current_epoch *= args.gradient_accumulation_steps\\n else:\\n steps_trained_in_current_epoch = 0\\n\\n logger.info(\\\" Continuing training from checkpoint, will skip to saved global_step\\\")\\n logger.info(f\\\" Continuing training from epoch {epochs_trained}\\\")\\n logger.info(f\\\" Continuing training from global step {self.state.global_step}\\\")\\n if not args.ignore_data_skip:\\n logger.info(\\n f\\\" Will skip the first {epochs_trained} epochs then the first {steps_trained_in_current_epoch} \\\"\\n \\\"batches in the first epoch. If this takes a lot of time, you can add the `--ignore_data_skip` \\\"\\n \\\"flag to your launch command, but you will resume the training on data already seen by your model.\\\"\\n )\\n if self.is_local_process_zero() and not args.disable_tqdm:\\n steps_trained_progress_bar = tqdm(total=steps_trained_in_current_epoch)\\n steps_trained_progress_bar.set_description(\\\"Skipping the first batches\\\")\\n\\n # Update the references\\n self.callback_handler.model = self.model\\n self.callback_handler.optimizer = self.optimizer\\n self.callback_handler.lr_scheduler = self.lr_scheduler\\n self.callback_handler.train_dataloader = train_dataloader\\n self.state.trial_name = self.hp_name(trial) if self.hp_name is not None else None\\n self.state.trial_params = hp_params(trial) if trial is not None else None\\n # This should be the same if the state has been saved but in case the training arguments changed, it's safer\\n # to set this after the load.\\n self.state.max_steps = max_steps\\n self.state.num_train_epochs = num_train_epochs\\n self.state.is_local_process_zero = self.is_local_process_zero()\\n self.state.is_world_process_zero = self.is_world_process_zero()\\n\\n # tr_loss is a tensor to avoid synchronization of TPUs through .item()\\n tr_loss = torch.tensor(0.0).to(args.device)\\n # _total_loss_scalar is updated everytime .item() has to be called on tr_loss and stores the sum of all losses\\n self._total_loss_scalar = 0.0\\n self._globalstep_last_logged = self.state.global_step\\n model.zero_grad()\\n\\n self.control = self.callback_handler.on_train_begin(args, self.state, self.control)\\n\\n # Skip the first epochs_trained epochs to get the random state of the dataloader at the right point.\\n if not args.ignore_data_skip:\\n for epoch in range(epochs_trained):\\n # We just need to begin an iteration to create the randomization of the sampler.\\n for _ in train_dataloader:\\n break\\n\\n for epoch in range(epochs_trained, num_train_epochs):\\n epoch_iterator = train_dataloader\\n\\n # Reset the past mems state at the beginning of each epoch if necessary.\\n if args.past_index >= 0:\\n self._past = None\\n\\n steps_in_epoch = (len(epoch_iterator) if train_dataset_is_sized else args.max_steps * args.gradient_accumulation_steps)\\n self.control = self.callback_handler.on_epoch_begin(args, self.state, self.control)\\n\\n for step, inputs in enumerate(epoch_iterator):\\n # Skip past any already trained steps if resuming training\\n if steps_trained_in_current_epoch > 0:\\n steps_trained_in_current_epoch -= 1\\n if steps_trained_progress_bar is not None:\\n steps_trained_progress_bar.update(1)\\n if steps_trained_in_current_epoch == 0:\\n self._load_rng_state(resume_from_checkpoint)\\n continue\\n\\n elif steps_trained_progress_bar is not None:\\n steps_trained_progress_bar.close()\\n steps_trained_progress_bar = None\\n\\n if step % args.gradient_accumulation_steps == 0:\\n self.control = self.callback_handler.on_step_begin(args, self.state, self.control)\\n\\n tr_loss += self.custom_training_step(model, inputs)\\n\\n self.current_flos += float(self.floating_point_ops(inputs))\\n\\n # Optimizer step for deepspeed must be called on every step regardless of the value of gradient_accumulation_steps\\n if (step + 1) % args.gradient_accumulation_steps == 0 or (\\n # last step in epoch but step is always smaller than gradient_accumulation_steps\\n steps_in_epoch <= args.gradient_accumulation_steps\\n and (step + 1) == steps_in_epoch\\n ):\\n # Gradient clipping\\n if args.max_grad_norm is not None and args.max_grad_norm > 0:\\n torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)\\n\\n # Optimizer step\\n optimizer_was_run = True\\n self.optimizer.step()\\n\\n if optimizer_was_run:\\n self.lr_scheduler.step()\\n\\n model.zero_grad()\\n\\n self.state.global_step += 1\\n self.state.epoch = epoch + (step + 1) / steps_in_epoch\\n self.control = self.callback_handler.on_step_end(args, self.state, self.control)\\n\\n self._maybe_log_save_evaluate(tr_loss, model, trial, epoch, ignore_keys_for_eval)\\n\\n if self.control.should_epoch_stop or self.control.should_training_stop:\\n break\\n\\n self.control = self.callback_handler.on_epoch_end(args, self.state, self.control)\\n self._maybe_log_save_evaluate(tr_loss, model, trial, epoch, ignore_keys_for_eval)\\n\\n if self.control.should_training_stop:\\n break\\n\\n if args.past_index and hasattr(self, \\\"_past\\\"):\\n # Clean the state at the end of training\\n delattr(self, \\\"_past\\\")\\n\\n logger.info(\\\"\\\\n\\\\nTraining completed. Do not forget to share your model on huggingface.co/models =)\\\\n\\\\n\\\")\\n if args.load_best_model_at_end and self.state.best_model_checkpoint is not None:\\n logger.info(f\\\"Loading best model from {self.state.best_model_checkpoint} (score: {self.state.best_metric}).\\\")\\n\\n # We load the model state dict on the CPU to avoid an OOM error.\\n state_dict = torch.load(os.path.join(self.state.best_model_checkpoint, WEIGHTS_NAME), map_location=\\\"cpu\\\")\\n # If the model is on the GPU, it still works!\\n self.model.load_state_dict(state_dict)\\n\\n metrics = speed_metrics(\\\"train\\\", start_time, self.state.max_steps)\\n self.store_flos()\\n metrics[\\\"total_flos\\\"] = self.state.total_flos\\n self.log(metrics)\\n\\n self.control = self.callback_handler.on_train_end(args, self.state, self.control)\\n # add remaining tr_loss\\n self._total_loss_scalar += tr_loss.item()\\n\\n self.is_in_train = False\\n\\n self._memory_tracker.stop_and_update_metrics(metrics)\\n\\n return TrainOutput(self.state.global_step, self._total_loss_scalar / self.state.global_step, metrics)\",\n \"def run(self):\\n # Get the checkpoint file\\n print('loading checkpoint file ...')\\n cp = torch.load(self.cfg.work_dir + '/latest.pth')\\n print('done')\\n\\n print('loading state dictionary ...')\\n # Initialize network first as separate modules so we can access WFCOS\\n backbone = build_backbone(self.cfg.model.backbone).cuda()\\n neck = build_neck(self.cfg.model.neck).cuda()\\n head = build_head(self.cfg.model.bbox_head).cuda()\\n\\n # Load the state dicts\\n backbone_state = OrderedDict()\\n neck_state = OrderedDict()\\n head_state = OrderedDict()\\n\\n for key in cp['state_dict'].keys():\\n if 'backbone' in key:\\n backbone_state[key.split('.', 1)[1]] = cp['state_dict'][key]\\n elif 'neck' in key:\\n neck_state[key.split('.', 1)[1]] = cp['state_dict'][key]\\n elif 'bbox_head' in key:\\n head_state[key.split('.', 1)[1]] = cp['state_dict'][key]\\n\\n backbone.load_state_dict(backbone_state)\\n neck.load_state_dict(neck_state)\\n head.load_state_dict(head_state)\\n\\n # Set to eval mode\\n backbone.eval()\\n neck.eval()\\n head.eval()\\n\\n print('done')\\n\\n print('starting inference validation run ...')\\n for i, (img, cls) in enumerate(self.loader):\\n out = backbone(img)\\n out = neck(out)\\n out = head(out)\\n\\n img_metas = [{'img_shape': (640, 800),\\n 'scale_factor': 1}]\\n bboxes = head.get_bboxes(out[0], out[1], out[2], img_metas,\\n self.cfg.test_cfg)\\n pass\\n print('done')\",\n \"def _load_checkpoint(cls, model: DeviceAwareModule, checkpoint_path: Path,\\n key_in_state_dict: str, use_gpu: bool) -> int:\\n logging.info(f\\\"Loading checkpoint {checkpoint_path}\\\")\\n checkpoint = ModelAndInfo.read_checkpoint(checkpoint_path, use_gpu)\\n\\n try:\\n state_dict = checkpoint[key_in_state_dict]\\n except KeyError:\\n logging.error(f\\\"Key {key_in_state_dict} not found in checkpoint\\\")\\n return False\\n\\n if isinstance(model, torch.nn.DataParallel):\\n result = model.module.load_state_dict(state_dict, strict=False)\\n else:\\n result = model.load_state_dict(state_dict, strict=False)\\n\\n if result.missing_keys:\\n logging.warning(f\\\"Missing keys in model checkpoint: {result.missing_keys}\\\")\\n if result.unexpected_keys:\\n logging.warning(f\\\"Unexpected keys in model checkpoint: {result.unexpected_keys}\\\")\\n\\n return checkpoint[ModelAndInfo.EPOCH_KEY]\",\n \"def try_and_init_from(self, path):\\n log.info(\\\"Loading weights from foreign checkpoint {}\\\".format(path))\\n if not os.path.exists(path):\\n raise ValueError(\\\"Checkpoint {} does not exist\\\".format(path))\\n\\n chkpt = th.load(path, map_location=th.device(\\\"cpu\\\"))\\n if \\\"model\\\" not in chkpt.keys() or chkpt[\\\"model\\\"] is None:\\n raise ValueError(\\\"{} has no model saved\\\".format(path))\\n\\n mdl = chkpt[\\\"model\\\"]\\n for n, p in self.model.named_parameters():\\n if n in mdl:\\n p2 = mdl[n]\\n if p2.shape != p.shape:\\n log.warning(\\\"Parameter {} ignored, checkpoint size does not match: {}, should be {}\\\".format(n, p2.shape, p.shape))\\n continue\\n log.debug(\\\"Parameter {} copied\\\".format(n))\\n p.data.copy_(p2)\\n else:\\n log.warning(\\\"Parameter {} ignored, not found in source checkpoint.\\\".format(n))\\n\\n log.info(\\\"Weights loaded from foreign checkpoint {}\\\".format(path))\",\n \"def initialize_model_from_cfg(args, gpu_id=0):\\n model = model_builder.Generalized_RCNN()\\n model.eval()\\n\\n if args.cuda:\\n model.cuda()\\n\\n if args.load_ckpt:\\n load_name = args.load_ckpt\\n logger.info(\\\"loading checkpoint %s\\\", load_name)\\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\\n net_utils.load_ckpt(model, checkpoint['model'])\\n\\n if args.load_detectron:\\n logger.info(\\\"loading detectron weights %s\\\", args.load_detectron)\\n load_caffe2_detectron_weights(model, args.load_detectron)\\n\\n model = mynn.DataParallel(model, cpu_keywords=['im_info', 'roidb'], minibatch=True)\\n\\n return model\",\n \"def load_model(self):\\n if self.ckpt_flag:\\n LOG('Skip Loading Pre-trained Model......')\\n else:\\n if self.params.pre_trained_from is not None and os.path.exists(self.params.pre_trained_from):\\n try:\\n LOG('Loading Pre-trained Model at %s' % self.params.pre_trained_from)\\n pretrain = torch.load(self.params.pre_trained_from)\\n self.network.load_state_dict(pretrain)\\n LOG('Pre-trained Model Loaded!')\\n except:\\n WARNING('Cannot load pre-trained model. Start training......')\\n else:\\n WARNING('Pre-trained model do not exits. Start training......')\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def train_model(\\n checkpoint: int,\\n checkpoint_step: int,\\n data_loader: torch.utils.data.DataLoader,\\n device: torch.device,\\n epoch: int,\\n experiment: str,\\n max_norm: float,\\n model: lmp.model.BaseRNNModel,\\n optimizer: Union[\\n torch.optim.SGD,\\n torch.optim.Adam,\\n ],\\n vocab_size: int\\n):\\n # Set experiment output folder.\\n file_dir = f'{lmp.path.DATA_PATH}/{experiment}'\\n\\n if not os.path.exists(file_dir):\\n os.makedirs(file_dir)\\n\\n # Set experiment log folder.\\n writer = torch.utils.tensorboard.SummaryWriter(\\n f'{lmp.path.DATA_PATH}/log/{experiment}'\\n )\\n\\n # Define objective function.\\n criterion = torch.nn.CrossEntropyLoss()\\n\\n # Step = number of updates.\\n # Every update must increment `step`.\\n step = 0\\n\\n # Set model to train mode.\\n model.train()\\n\\n # Clean up gradient in model parameters.\\n model.zero_grad()\\n\\n # Initialize total loss.\\n total_loss = 0.0\\n\\n for cur_epoch in range(epoch):\\n\\n epoch_iterator = tqdm(\\n data_loader,\\n desc=f'epoch: {cur_epoch}, loss: {0:.6f}'\\n )\\n\\n for x, y in epoch_iterator:\\n # Increment step for each update.\\n step += 1\\n\\n # Continue training from previous checkpoint step.\\n if step < checkpoint:\\n continue\\n\\n # Put tensors on to specified device (CPU or GPU). Reshape `y` into\\n # shape (B x S) for cross-entropy.\\n # x.size = (B, S)\\n # y.size = (B x S)\\n x = x.to(device)\\n y = y.reshape(-1).to(device)\\n\\n # Forward pass.\\n # pred_y_logits.size = (B, S, V)\\n pred_y_logits = model(x)\\n\\n # Reshape `pred_y_logits` into shape (B x S, V) for cross-entropy.\\n pred_y_logits = pred_y_logits.reshape(-1, vocab_size)\\n\\n # Perform cross-entropy.\\n loss = criterion(pred_y_logits, y)\\n\\n # Calculate total loss.\\n total_loss += loss.item()\\n\\n # Log loss.\\n epoch_iterator.set_description(\\n f'epoch: {cur_epoch}, loss: {loss.item():.6f}'\\n )\\n\\n # Backward pass.\\n loss.backward()\\n\\n # Perform gradient clipping to avoid gradient explosion.\\n torch.nn.utils.clip_grad_norm_(\\n model.parameters(),\\n max_norm\\n )\\n\\n # Gradient descent.\\n optimizer.step()\\n\\n # `torch` required manually clean up gradient.\\n optimizer.zero_grad()\\n\\n # Save checkpoint for each `checkpoint_step`.\\n if step % checkpoint_step == 0:\\n torch.save(\\n model.state_dict(),\\n os.path.join(\\n file_dir,\\n f'model-{step}.pt'\\n )\\n )\\n torch.save(\\n optimizer.state_dict(),\\n os.path.join(\\n file_dir,\\n f'optimizer-{step}.pt'\\n )\\n )\\n # Log average loss.\\n writer.add_scalar(\\n f'{experiment}/loss',\\n total_loss / checkpoint_step,\\n step\\n )\\n total_loss = 0.0\\n\\n # Save last checkpoint.\\n torch.save(\\n model.state_dict(),\\n os.path.join(\\n file_dir,\\n f'model-{step}.pt'\\n )\\n )\\n torch.save(\\n optimizer.state_dict(),\\n os.path.join(\\n file_dir,\\n f'optimizer-{step}.pt'\\n )\\n )\",\n \"def train(self, config, **kwargs):\\n\\n config_parameters = utils.parse_config_or_kwargs(config, **kwargs)\\n outputdir = Path(\\n config_parameters['outputpath'], config_parameters['model'],\\n \\\"{}_{}\\\".format(\\n datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%m'),\\n uuid.uuid1().hex[:8]))\\n # Early init because of creating dir\\n checkpoint_handler = ModelCheckpoint(\\n outputdir,\\n 'run',\\n n_saved=1,\\n require_empty=False,\\n create_dir=True,\\n score_function=lambda engine: -engine.state.metrics['Loss'],\\n save_as_state_dict=False,\\n score_name='loss')\\n logger = utils.getfile_outlogger(Path(outputdir, 'train.log'))\\n logger.info(\\\"Storing files in {}\\\".format(outputdir))\\n # utils.pprint_dict\\n utils.pprint_dict(config_parameters, logger.info)\\n logger.info(\\\"Running on device {}\\\".format(DEVICE))\\n labels_df = pd.read_csv(config_parameters['trainlabel'], sep=' ')\\n labels_df['encoded'], encoder = utils.encode_labels(\\n labels=labels_df['bintype'])\\n train_df, cv_df = utils.split_train_cv(labels_df)\\n\\n transform = utils.parse_transforms(config_parameters['transforms'])\\n utils.pprint_dict({'Classes': encoder.classes_},\\n logger.info,\\n formatter='pretty')\\n utils.pprint_dict(transform, logger.info, formatter='pretty')\\n if 'sampler' in config_parameters and config_parameters[\\n 'sampler'] == 'MinimumOccupancySampler':\\n # Asserts that each \\\"batch\\\" contains at least one instance\\n train_sampler = dataset.MinimumOccupancySampler(\\n np.stack(train_df['encoded'].values))\\n\\n sampling_kwargs = {\\\"sampler\\\": train_sampler, \\\"shuffle\\\": False}\\n elif 'shuffle' in config_parameters and config_parameters['shuffle']:\\n sampling_kwargs = {\\\"shuffle\\\": True}\\n else:\\n sampling_kwargs = {\\\"shuffle\\\": False}\\n\\n logger.info(\\\"Using Sampler {}\\\".format(sampling_kwargs))\\n\\n colname = config_parameters.get('colname', ('filename', 'encoded')) #\\n trainloader = dataset.getdataloader(\\n train_df,\\n config_parameters['traindata'],\\n transform=transform,\\n batch_size=config_parameters['batch_size'],\\n colname=colname, # For other datasets with different key names\\n num_workers=config_parameters['num_workers'],\\n **sampling_kwargs)\\n cvdataloader = dataset.getdataloader(\\n cv_df,\\n config_parameters['traindata'],\\n transform=None,\\n shuffle=False,\\n colname=colname, # For other datasets with different key names\\n batch_size=config_parameters['batch_size'],\\n num_workers=config_parameters['num_workers'])\\n if 'pretrained' in config_parameters and config_parameters[\\n 'pretrained'] is not None:\\n model = models.load_pretrained(config_parameters['pretrained'],\\n outputdim=len(encoder.classes_))\\n else:\\n model = getattr(models, config_parameters['model'],\\n 'LightCNN')(inputdim=trainloader.dataset.datadim,\\n outputdim=len(encoder.classes_),\\n **config_parameters['model_args'])\\n\\n if config_parameters['optimizer'] == 'AdaBound':\\n try:\\n import adabound\\n optimizer = adabound.AdaBound(\\n model.parameters(), **config_parameters['optimizer_args'])\\n except ImportError:\\n logger.info(\\n \\\"Adabound package not found, install via pip install adabound. Using Adam instead\\\"\\n )\\n config_parameters['optimizer'] = 'Adam'\\n config_parameters['optimizer_args'] = {\\n } # Default adam is adabount not found\\n else:\\n optimizer = getattr(\\n torch.optim,\\n config_parameters['optimizer'],\\n )(model.parameters(), **config_parameters['optimizer_args'])\\n\\n utils.pprint_dict(optimizer, logger.info, formatter='pretty')\\n utils.pprint_dict(model, logger.info, formatter='pretty')\\n if DEVICE.type != 'cpu' and torch.cuda.device_count() > 1:\\n logger.info(\\\"Using {} GPUs!\\\".format(torch.cuda.device_count()))\\n model = torch.nn.DataParallel(model)\\n criterion = torch.nn.CrossEntropyLoss().to(DEVICE)\\n model = model.to(DEVICE)\\n\\n precision = Precision()\\n recall = Recall()\\n f1_score = (precision * recall * 2 / (precision + recall)).mean()\\n metrics = {\\n 'Loss': Loss(criterion),\\n 'Precision': precision.mean(),\\n 'Recall': recall.mean(),\\n 'Accuracy': Accuracy(),\\n 'F1': f1_score,\\n }\\n\\n # batch contains 3 elements, X,Y and filename. Filename is only used\\n # during evaluation\\n def _prep_batch(batch, device=DEVICE, non_blocking=False):\\n x, y, _ = batch\\n return (convert_tensor(x, device=device,\\n non_blocking=non_blocking),\\n convert_tensor(y, device=device,\\n non_blocking=non_blocking))\\n\\n train_engine = create_supervised_trainer(model,\\n optimizer=optimizer,\\n loss_fn=criterion,\\n prepare_batch=_prep_batch,\\n device=DEVICE)\\n inference_engine = create_supervised_evaluator(\\n model, metrics=metrics, prepare_batch=_prep_batch, device=DEVICE)\\n\\n RunningAverage(output_transform=lambda x: x).attach(\\n train_engine, 'run_loss') # Showing progressbar during training\\n pbar = ProgressBar(persist=False)\\n pbar.attach(train_engine, ['run_loss'])\\n scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,\\n patience=3,\\n factor=0.1)\\n\\n @inference_engine.on(Events.COMPLETED)\\n def update_reduce_on_plateau(engine):\\n val_loss = engine.state.metrics['Loss']\\n if 'ReduceLROnPlateau' == scheduler.__class__.__name__:\\n scheduler.step(val_loss)\\n else:\\n scheduler.step()\\n\\n early_stop_handler = EarlyStopping(\\n patience=5,\\n score_function=lambda engine: -engine.state.metrics['Loss'],\\n trainer=train_engine)\\n inference_engine.add_event_handler(Events.EPOCH_COMPLETED,\\n early_stop_handler)\\n inference_engine.add_event_handler(Events.EPOCH_COMPLETED,\\n checkpoint_handler, {\\n 'model': model,\\n 'encoder': encoder,\\n 'config': config_parameters,\\n })\\n\\n @train_engine.on(Events.EPOCH_COMPLETED)\\n def compute_validation_metrics(engine):\\n inference_engine.run(cvdataloader)\\n results = inference_engine.state.metrics\\n output_str_list = [\\n \\\"Validation Results - Epoch : {:<5}\\\".format(engine.state.epoch)\\n ]\\n for metric in metrics:\\n output_str_list.append(\\\"{} {:<5.3f}\\\".format(\\n metric, results[metric]))\\n logger.info(\\\" \\\".join(output_str_list))\\n pbar.n = pbar.last_print_n = 0\\n\\n train_engine.run(trainloader, max_epochs=config_parameters['epochs'])\\n return outputdir\",\n \"def __init__(self, model: str, **kwargs):\\n super().__init__(model=model, **kwargs)\\n self.path = model\\n self.model = get_zennet()\\n\\n model_pth_path = osp.join(self.path, ModelFile.TORCH_MODEL_FILE)\\n\\n checkpoint = torch.load(model_pth_path, map_location='cpu')\\n if 'state_dict' in checkpoint:\\n state_dict = checkpoint['state_dict']\\n else:\\n state_dict = checkpoint\\n\\n self.model.load_state_dict(state_dict, strict=True)\\n logger.info('load model done')\",\n \"def train_model(config, environ, train_data, test_data, trainval_data=None):\\n np.random.seed(0)\\n if not hasattr(config, \\\"seed\\\"):\\n tf.set_random_seed(1234)\\n log.info(\\\"Setting tensorflow random seed={:d}\\\".format(1234))\\n else:\\n log.info(\\\"Setting tensorflow random seed={:d}\\\".format(config.seed))\\n tf.set_random_seed(config.seed)\\n if environ.verbose:\\n verbose_level = 0\\n else:\\n verbose_level = 2\\n\\n if trainval_data is None:\\n trainval_data = train_data\\n\\n log.info(\\\"Environment: {}\\\".format(environ.__dict__))\\n log.info(\\\"Config: {}\\\".format(config.__dict__))\\n\\n save_folder = os.path.join(environ.save_folder, environ.exp_id)\\n logs_folder = os.path.join(environ.logs_folder, environ.exp_id)\\n with log.verbose_level(verbose_level):\\n exp_logger = ExperimentLogger(logs_folder)\\n\\n if not hasattr(config, \\\"seed\\\"):\\n data_seed = 0\\n else:\\n data_seed = config.seed\\n\\n # Gets data iterators.\\n train_iter = get_iter(\\n train_data,\\n batch_size=config.batch_size,\\n shuffle=True,\\n cycle=True,\\n prefetch=config.prefetch,\\n seed=data_seed,\\n num_worker=25,\\n queue_size=500)\\n trainval_iter = get_iter(\\n train_data,\\n batch_size=config.batch_size,\\n shuffle=True,\\n cycle=True,\\n prefetch=config.prefetch,\\n num_worker=10,\\n queue_size=200)\\n test_iter = get_iter(\\n test_data,\\n batch_size=config.batch_size,\\n shuffle=False,\\n cycle=False,\\n prefetch=config.prefetch,\\n num_worker=10,\\n queue_size=200)\\n\\n # Builds models.\\n log.info(\\\"Building models\\\")\\n with tf.name_scope(\\\"Train\\\"):\\n with tf.variable_scope(\\\"Model\\\", reuse=None):\\n with tf.device(environ.device):\\n if config.model.startswith(\\\"resnet\\\"):\\n m = ResNetModel(config, is_training=True)\\n else:\\n m = CNNModel(config, is_training=True)\\n\\n with tf.name_scope(\\\"Valid\\\"):\\n with tf.variable_scope(\\\"Model\\\", reuse=True):\\n with tf.device(environ.device):\\n if config.model.startswith(\\\"resnet\\\"):\\n mvalid = ResNetModel(config, is_training=False)\\n else:\\n mvalid = CNNModel(config, is_training=False)\\n\\n # Initializes variables.\\n with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:\\n saver = tf.train.Saver()\\n sess.run(tf.global_variables_initializer())\\n\\n def train_step():\\n \\\"\\\"\\\"Train step.\\\"\\\"\\\"\\n batch = train_iter.next()\\n feed_data = {m.input: batch[\\\"img\\\"], m.label: batch[\\\"label\\\"]}\\n cost, ce, _ = sess.run([m.cost, m.cross_ent, m.train_op],\\n feed_dict=feed_data)\\n return ce\\n\\n def evaluate(data_iter, nbatches):\\n \\\"\\\"\\\"Runs evaluation.\\\"\\\"\\\"\\n num_correct = 0.0\\n count = 0\\n if nbatches == -1:\\n iter_ = data_iter\\n else:\\n iter_ = range(nbatches)\\n\\n for bb in iter_:\\n if nbatches == -1:\\n batch = bb\\n else:\\n batch = data_iter.next()\\n feed_data = {mvalid.input: batch[\\\"img\\\"]}\\n y = sess.run(mvalid.output, feed_dict=feed_data)\\n pred_label = np.argmax(y, axis=1)\\n num_correct += np.sum(\\n np.equal(pred_label, batch[\\\"label\\\"]).astype(float))\\n count += pred_label.size\\n acc = (num_correct / count)\\n return acc\\n\\n def save():\\n \\\"\\\"\\\"Snapshots a model.\\\"\\\"\\\"\\n if not os.path.isdir(save_folder):\\n os.makedirs(save_folder)\\n config_file = os.path.join(save_folder, \\\"conf.json\\\")\\n environ_file = os.path.join(save_folder, \\\"env.json\\\")\\n with open(config_file, \\\"w\\\") as f:\\n f.write(config.to_json())\\n with open(environ_file, \\\"w\\\") as f:\\n f.write(environ.to_json())\\n log.info(\\\"Saving to {}\\\".format(save_folder))\\n saver.save(\\n sess,\\n os.path.join(save_folder, \\\"model.ckpt\\\"),\\n global_step=m.global_step)\\n\\n def train():\\n \\\"\\\"\\\"Train loop.\\\"\\\"\\\"\\n lr = config.base_learn_rate\\n lr_decay_steps = config.lr_decay_steps\\n max_train_iter = config.max_train_iter\\n m.assign_lr(sess, lr)\\n\\n if environ.verbose:\\n loop = range(max_train_iter)\\n else:\\n loop = pb.get(max_train_iter)\\n\\n for niter in loop:\\n # decrease learning rate\\n if len(lr_decay_steps) > 0:\\n if (niter + 1) == lr_decay_steps[0]:\\n lr *= 0.1\\n m.assign_lr(sess, lr)\\n lr_decay_steps.pop(0)\\n ce = train_step()\\n if (niter + 1) % config.disp_iter == 0 or niter == 0:\\n exp_logger.log_train_ce(niter, ce)\\n if (niter + 1) % config.valid_iter == 0 or niter == 0:\\n acc = evaluate(trainval_iter, 10)\\n exp_logger.log_train_acc(niter, acc)\\n test_iter.reset()\\n acc = evaluate(test_iter, -1)\\n log.info(\\\"Experment ID {}\\\".format(environ.exp_id))\\n exp_logger.log_valid_acc(niter, acc)\\n if (niter + 1) % config.save_iter == 0:\\n save()\\n test_iter.reset()\\n acc = evaluate(test_iter, -1)\\n return acc\\n\\n acc = train()\\n return acc\",\n \"def save_model(self, checkpoint_path, epoch):\\n self.saver.save(self.sess, checkpoint_path, global_step = epoch)\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(f\\\"Checkpoint '{checkpoint_path}' does not exist\\\")\\n\\n state = torch.load(checkpoint_path)\\n try:\\n model.load_state_dict(state['model_state_dict'])\\n except BaseException as e:\\n print('Failed to do something: ' + str(e))\\n\\n if optimizer is not None:\\n try:\\n optimizer.load_state_dict(state['optimizer_state_dict'])\\n except Exception as e:\\n print(e)\\n\\n return state\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77288234","0.7422351","0.73331386","0.7309896","0.7146994","0.7120653","0.709593","0.70095086","0.6994309","0.6936953","0.6916758","0.6907432","0.6901133","0.685239","0.6851834","0.682932","0.6783703","0.6779041","0.6770681","0.6748651","0.6746794","0.67368805","0.6731563","0.67264324","0.670968","0.6671762","0.66528815","0.66475177","0.6645826","0.6637641","0.66101646","0.66010445","0.66010445","0.6596317","0.6593572","0.65878546","0.65843034","0.65838987","0.6548627","0.6546977","0.6546659","0.6541168","0.6533427","0.65101206","0.65097","0.65077376","0.64917064","0.64886","0.64727765","0.6471805","0.64422655","0.6441939","0.644122","0.6437587","0.6434152","0.6431633","0.6426752","0.6425945","0.63933456","0.6392295","0.63907516","0.6390588","0.6386796","0.63828975","0.63773906","0.6375171","0.6371313","0.6359675","0.6358668","0.6352871","0.6350757","0.6350401","0.63464296","0.63437796","0.63432944","0.63346267","0.6334598","0.63186693","0.63083464","0.63072896","0.6300133","0.6299943","0.6299492","0.62972635","0.62901527","0.6288992","0.6287761","0.6283841","0.6283273","0.6277323","0.62664723","0.62640643","0.6259985","0.6251159","0.6251159","0.6250616","0.624678","0.6227893","0.6219129","0.62175655","0.621257"],"string":"[\n \"0.77288234\",\n \"0.7422351\",\n \"0.73331386\",\n \"0.7309896\",\n \"0.7146994\",\n \"0.7120653\",\n \"0.709593\",\n \"0.70095086\",\n \"0.6994309\",\n \"0.6936953\",\n \"0.6916758\",\n \"0.6907432\",\n \"0.6901133\",\n \"0.685239\",\n \"0.6851834\",\n \"0.682932\",\n \"0.6783703\",\n \"0.6779041\",\n \"0.6770681\",\n \"0.6748651\",\n \"0.6746794\",\n \"0.67368805\",\n \"0.6731563\",\n \"0.67264324\",\n \"0.670968\",\n \"0.6671762\",\n \"0.66528815\",\n \"0.66475177\",\n \"0.6645826\",\n \"0.6637641\",\n \"0.66101646\",\n \"0.66010445\",\n \"0.66010445\",\n \"0.6596317\",\n \"0.6593572\",\n \"0.65878546\",\n \"0.65843034\",\n \"0.65838987\",\n \"0.6548627\",\n \"0.6546977\",\n \"0.6546659\",\n \"0.6541168\",\n \"0.6533427\",\n \"0.65101206\",\n \"0.65097\",\n \"0.65077376\",\n \"0.64917064\",\n \"0.64886\",\n \"0.64727765\",\n \"0.6471805\",\n \"0.64422655\",\n \"0.6441939\",\n \"0.644122\",\n \"0.6437587\",\n \"0.6434152\",\n \"0.6431633\",\n \"0.6426752\",\n \"0.6425945\",\n \"0.63933456\",\n \"0.6392295\",\n \"0.63907516\",\n \"0.6390588\",\n \"0.6386796\",\n \"0.63828975\",\n \"0.63773906\",\n \"0.6375171\",\n \"0.6371313\",\n \"0.6359675\",\n \"0.6358668\",\n \"0.6352871\",\n \"0.6350757\",\n \"0.6350401\",\n \"0.63464296\",\n \"0.63437796\",\n \"0.63432944\",\n \"0.63346267\",\n \"0.6334598\",\n \"0.63186693\",\n \"0.63083464\",\n \"0.63072896\",\n \"0.6300133\",\n \"0.6299943\",\n \"0.6299492\",\n \"0.62972635\",\n \"0.62901527\",\n \"0.6288992\",\n \"0.6287761\",\n \"0.6283841\",\n \"0.6283273\",\n \"0.6277323\",\n \"0.62664723\",\n \"0.62640643\",\n \"0.6259985\",\n \"0.6251159\",\n \"0.6251159\",\n \"0.6250616\",\n \"0.624678\",\n \"0.6227893\",\n \"0.6219129\",\n \"0.62175655\",\n \"0.621257\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":4479,"cells":{"query":{"kind":"string","value":"Creates a torch optimizer for the given model, and stores it as an instance variable in the current object."},"document":{"kind":"string","value":"def create_optimizer(self) -> None:\n # Make sure model is created before we create optimizer\n if self._model is None:\n raise ValueError(\"Model checkpoint must be created before optimizer checkpoint can be loaded.\")\n\n # Select optimizer type\n if self.config.optimizer_type in [OptimizerType.Adam, OptimizerType.AMSGrad]:\n self._optimizer = torch.optim.Adam(self._model.parameters(), self.config.l_rate,\n self.config.adam_betas, self.config.opt_eps, self.config.weight_decay,\n amsgrad=self.config.optimizer_type == OptimizerType.AMSGrad)\n elif self.config.optimizer_type == OptimizerType.SGD:\n self._optimizer = torch.optim.SGD(self._model.parameters(), self.config.l_rate, self.config.momentum,\n weight_decay=self.config.weight_decay)\n elif self.config.optimizer_type == OptimizerType.RMSprop:\n self._optimizer = RMSprop(self._model.parameters(), self.config.l_rate, self.config.rms_alpha,\n self.config.opt_eps,\n self.config.weight_decay, self.config.momentum)\n else:\n raise NotImplementedError(f\"Optimizer type {self.config.optimizer_type.value} is not implemented\")"},"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 optimizer(self, model: nn.Module) -> torch.optim.Optimizer: # type: ignore\n pass","def build_optimizer(model: nn.Module, args: Namespace) -> Optimizer:\n params = [{'params': model.parameters(), 'lr': args.init_lr, 'weight_decay': 0}]\n\n return Adam(params)","def get_optimizer(args, model: torch.nn.Module):\n return Adam(model.parameters(), lr=args.lr)","def optimizer_creator(model, config):\n return torch.optim.SGD(model.parameters(), lr=config.get(\"lr\", 1e-4))","def __init__(self, model, optimizer=tf.compat.v1.train.AdamOptimizer, optimizer_arguments={}):\n \n self.model = model\n self.train_optimizer = optimizer(**optimizer_arguments).minimize(self.model.trn_loss)\n self.train_reg_optimizer = optimizer(**optimizer_arguments).minimize(self.model.reg_loss)","def create_optimizer(optimizer_name, model, config):\n if optimizer_name == 'adadelta':\n return torch.optim.Adadelta(model.parameters(),\n lr=config['adadelta_lr'],\n rho=config['adadelta_rho'],\n weight_decay=config['adadelta_weight_decay'],\n eps=config['adadelta_eps'])\n else:\n raise Exception('Optimizer \\'{}\\' not supported.'.format(optimizer_name))","def create_train_op(self, model, learning_rate):\n if self.optim_type == 'adagrad':\n optimizer = torch.optim.Adagrad(model.parameters(), lr=learning_rate, weight_decay=self.args.weight_decay)\n elif self.optim_type == 'adadelta':\n optimizer = torch.optim.Adadelta(model.parameters(), lr=learning_rate, weight_decay=self.args.weight_decay)\n elif self.optim_type == 'adam':\n optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=self.args.weight_decay)\n elif self.optim_type == 'rprop':\n optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate, weight_decay=self.args.weight_decay)\n elif self.optim_type == 'sgd':\n optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=self.args.momentum,\n weight_decay=self.args.weight_decay)\n else:\n raise NotImplementedError('Unsupported optimizer: {}'.format(self.optim_type))\n return optimizer","def build_torch_optimizer(model, opt):\n params = [p for p in model.parameters() if p.requires_grad]\n if opt.optim == 'sgd':\n optimizer = optim.SGD(params, lr=opt.learning_rate)\n elif opt.optim == 'adagrad':\n optimizer = optim.Adagrad(\n params,\n lr=opt.learning_rate,\n initial_accumulator_value=opt.adagrad_accumulator_init)\n elif opt.optim == 'adadelta':\n optimizer = optim.Adadelta(params, lr=opt.learning_rate)\n elif opt.optim == 'adam':\n optimizer = optim.Adam(\n params,\n lr=opt.learning_rate,\n betas=(opt.adam_beta1, opt.adam_beta2),\n weight_decay=opt.learning_rate_decay,\n eps=1e-9)\n else:\n raise ValueError('Invalid optimizer type: ' + opt.optim)\n\n return optimizer","def get_optimizer(self, model):\n optimizer = scaffold_optimizer.ScaffoldOptimizer(\n model.parameters(),\n lr=Config().trainer.learning_rate,\n momentum=Config().trainer.momentum,\n weight_decay=Config().trainer.weight_decay)\n\n optimizer.server_update_direction = self.server_update_direction\n optimizer.client_update_direction = self.client_update_direction\n optimizer.client_id = self.client_id\n optimizer.update_flag = True\n\n return optimizer","def create_model_optimizer(net,alpha):\n optimizer = chainer.optimizers.Adam(alpha=alpha)\n optimizer.setup(net)\n return optimizer","def create_optimizer(model: torch.nn.Module, optimizer_name: str, learning_rate: float, weight_decay: float = 0.0,\n momentum: float = 0.0) -> torch.optim.Optimizer:\n if optimizer_name.lower() == \"adadelta\":\n optimizer = torch.optim.Adadelta(model.parameters(), learning_rate, weight_decay=weight_decay)\n elif optimizer_name.lower() == \"adam\":\n optimizer = torch.optim.Adam(model.parameters(), learning_rate, weight_decay=weight_decay)\n elif optimizer_name.lower() == \"sgd\":\n optimizer = torch.optim.SGD(model.parameters(), learning_rate, momentum,\n weight_decay=weight_decay)\n elif optimizer_name.lower() == \"rmsprop\":\n optimizer = torch.optim.RMSprop(model.parameters(), learning_rate, weight_decay=weight_decay,\n momentum=momentum)\n else:\n raise ValueError(\"SystemLog: The optimizer must be Adadelta, Adam, SGD, or RMSprop \"\n \"(optimizer: {})\".format(optimizer_name))\n\n return optimizer","def get_optimizer(model):\n optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.5, 0.999))\n return optimizer","def optimizer_setup(model, params):\n if params.optimizer == 'adam':\n if params.freeze_backbone:\n optimizer = optimizer_handler.layer_specific_adam(model, params)\n else:\n optimizer = optimizer_handler.plain_adam(model, params)\n elif params.optimizer == 'sgd':\n if params.freeze_backbone:\n optimizer = optimizer_handler.layer_specific_sgd(model, params)\n else:\n optimizer = optimizer_handler.plain_sgd(model, params)\n\n if params.zero_bn_bias_decay:\n optimizer = zero_wdcay_bn_bias(optimizer)\n\n return optimizer","def initialize(self): \n self.optimizer = torch.optim.Adam(self.model.parameters(), lr=config.LR)","def optimizer_factory(config, model):\n params = model.parameters()\n\n optimizer = config[\"loss\"].get(\"optimizer\", \"Adam\")\n lr = config[\"loss\"].get(\"lr\", 1e-3)\n momentum = config[\"loss\"].get(\"momentum\", 0.9)\n\n if optimizer == \"SGD\":\n return optim.SGD(params, lr=lr, momentum=momentum)\n elif optimizer == \"Adam\":\n return optim.Adam(params, lr=lr)\n else:\n raise NotImplementedError()","def make_optimizer(model, lr, opt, weight_decay):\n optimizers = {\n 'adam': optim.Adam,\n 'adamax': optim.Adamax,\n 'rmsprop': optim.RMSprop,\n }\n\n optimizer = optimizers[opt](model.parameters(), lr=lr,\n weight_decay=weight_decay)\n\n return optimizer","def init_optimizer(model, config, exact_layers=None):\n opt_type = config.optimizer\n if exact_layers:\n logger.info('Learning exact layers, number=%d', len(exact_layers))\n parameters = []\n for i, layer in enumerate(exact_layers):\n if isinstance(layer, tuple) and len(layer) == 2:\n layer, multiplier = layer\n init_multiplier = 1\n elif isinstance(layer, tuple) and len(layer) == 3:\n layer, init_multiplier, multiplier = layer\n else:\n multiplier = 1\n init_multiplier = 1\n lr = config.lr * multiplier\n init_lr = config.lr * multiplier * init_multiplier\n logger.info('Layer=%d, lr=%.5f', i, init_lr)\n parameters.append({'params': layer.parameters(), 'lr': init_lr, 'after_warmup_lr': lr})\n else:\n logger.info('Optimizing all parameters, lr=%.5f', config.lr)\n parameters = model.parameters()\n\n if opt_type == 'sgd':\n optimizer = torch.optim.SGD(parameters, config.lr, momentum=config.momentum, weight_decay=config.weight_decay)\n elif opt_type == 'adam':\n optimizer = torch.optim.Adam(parameters, lr=config.lr, weight_decay=config.weight_decay)\n elif opt_type == 'yf':\n optimizer = YFOptimizer(parameters, config.lr, mu=config.momentum, weight_decay=config.weight_decay,\n clip_thresh=0.1)\n else:\n raise TypeError, 'Unknown optimizer type=%s' % (opt_type, )\n return optimizer","def __init__(self, model, adv_func, dist_func, attack_lr=1e-2,\n init_weight=10., max_weight=80., binary_step=10, num_iter=500):\n\n self.model = model.cuda()\n self.model.eval()\n\n self.adv_func = adv_func\n self.dist_func = dist_func\n self.attack_lr = attack_lr\n self.init_weight = init_weight\n self.max_weight = max_weight\n self.binary_step = binary_step\n self.num_iter = num_iter","def create_optimizer(self, run_configuration, rng=None):\n @functools.partial(jax.jit, static_argnums=(1, 2))\n def create_model(rng, example, model_cls):\n with flax.deprecated.nn.attention.Cache().mutate() as cache_def:\n _, initial_params = model_cls.init(\n rng,\n example,\n cache=cache_def)\n model = flax.deprecated.nn.Model(model_cls, initial_params)\n return model, cache_def\n\n config = self.config\n dataset = run_configuration.dataset_info.dataset\n\n rng = rng if rng is not None else jax.random.PRNGKey(0)\n learning_rate = config.opt.learning_rate\n example = self.as_example(next(iter(dataset)))\n model_cls = run_configuration.model\n model, unused_cache_def = create_model(rng, example, model_cls)\n return optimizer_utils.create_optimizer(model, learning_rate)","def initialize_optimizer(model, args):\n parameters = [p for p in model.parameters() if p.requires_grad]\n if args.optimizer == 'sgd':\n optimizer = optim.SGD(parameters, args.learning_rate,\n momentum=args.momentum,\n weight_decay=args.weight_decay)\n elif args.optimizer == 'adam':\n optimizer = optim.Adam(parameters, args.learning_rate,\n weight_decay=args.weight_decay)\n elif args.optimizer == 'adamax':\n optimizer = optim.Adamax(parameters, args.learning_rate,\n weight_decay=args.weight_decay)\n elif args.optimizer == 'adagrad':\n optimizer = optim.Adagrad(parameters, args.learning_rate,\n weight_decay=args.weight_decay)\n scheduler = ReduceLROnPlateau(optimizer, 'min', verbose=True)\n return optimizer, scheduler","def build_optimizer(cfg: CfgNode, model: torch.nn.Module) -> torch.optim.Optimizer:\n norm_module_types = (\n torch.nn.BatchNorm1d,\n torch.nn.BatchNorm2d,\n torch.nn.BatchNorm3d,\n torch.nn.SyncBatchNorm,\n # NaiveSyncBatchNorm inherits from BatchNorm2d\n torch.nn.GroupNorm,\n torch.nn.InstanceNorm1d,\n torch.nn.InstanceNorm2d,\n torch.nn.InstanceNorm3d,\n torch.nn.LayerNorm,\n torch.nn.LocalResponseNorm,\n )\n params: List[Dict[str, Any]] = []\n memo: Set[torch.nn.parameter.Parameter] = set()\n for module in model.modules():\n for key, value in module.named_parameters(recurse=False):\n if not value.requires_grad:\n continue\n # Avoid duplicating parameters\n if value in memo:\n continue\n memo.add(value)\n lr = cfg.SOLVER.BASE_LR\n weight_decay = cfg.SOLVER.WEIGHT_DECAY\n if isinstance(module, norm_module_types):\n weight_decay = cfg.SOLVER.WEIGHT_DECAY_NORM\n elif key == \"bias\":\n # NOTE: unlike Detectron v1, we now default BIAS_LR_FACTOR to 1.0\n # and WEIGHT_DECAY_BIAS to WEIGHT_DECAY so that bias optimizer\n # hyperparameters are by default exactly the same as for regular\n # weights.\n lr = cfg.SOLVER.BASE_LR * cfg.SOLVER.BIAS_LR_FACTOR\n weight_decay = cfg.SOLVER.WEIGHT_DECAY_BIAS\n params += [{\"params\": [value], \"lr\": lr, \"weight_decay\": weight_decay}]\n\n optimizer = torch.optim.SGD(params, cfg.SOLVER.BASE_LR, momentum=cfg.SOLVER.MOMENTUM)\n return optimizer","def __init__(self, model, src_vocab, tgt_vocab):\n self.max_length = 120\n if torch.cuda.is_available():\n self.model = model.cuda()\n else:\n self.model = model.cpu()\n self.model.eval()\n self.src_vocab = src_vocab\n self.tgt_vocab = tgt_vocab","def optimize(self, model):\n model.optimize_params(\n max_iters=self.max_iters, max_beta_iters=self.max_beta_iters,\n max_U_iters=self.max_U_iters, rel_tol=self.rel_tol,\n optimize_beta=self.optimize_beta, optimize_U=self.optimize_U,\n compute_D=self.compute_D\n )\n return model","def get_optimizer(model, lr, transfer_optim):\n\n # different otpimizer lr for transfer to reuse low level features\n if transfer_optim:\n if isinstance(model, UNetRegressionModel):\n optimizer = torch.optim.Adam([{'params':\n list(model.msd.inc.parameters()) +\n list(model.msd.down1.parameters()) +\n list(model.msd.down2.parameters()), 'lr': 1e-6},\n {'params': \n list(model.msd.down3.parameters()) +\n list(model.msd.down4.parameters()) +\n list(model.msd.up1.parameters()), 'lr': 1e-5},\n {'params': \n list(model.msd.up2.parameters()) + list(model.msd.up3.parameters()) +\n list(model.msd.up4.parameters()) + list(model.msd.outc.parameters()), 'lr': 1e-4},\n ])\n\n else:\n params = list(model.msd.parameters())\n # case: MSD_d30\n if len(params) < 40:\n optimizer = torch.optim.Adam([{'params': params[1:10], 'lr':1e-6},\n {'params': params[:0]+ params[10:20], 'lr':1e-5},\n {'params': params[20:], 'lr':1e-4},\n ])\n # case: MSD_d80\n else:\n optimizer = torch.optim.Adam([{'params': params[1:20], 'lr':1e-6},\n {'params': params[:0]+ params[20:40], 'lr':1e-5},\n {'params': params[40:], 'lr':1e-4},\n ])\n else:\n optimizer = torch.optim.Adam(model.msd.parameters(), lr)\n\n return optimizer","def __init__(self, model_class, model=None, env=None, exploration=None,\n gamma=0.99, memory_size=100000, batch_size=64, target_update_frequency=1000, saving_dir=None):\n self.model_class = model_class\n self.env = env\n self.exploration = exploration\n self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n self.policy_net = None\n self.target_net = None\n self.optimizer = None\n if model:\n self.policy_net = model\n self.target_net = copy.deepcopy(self.policy_net)\n self.policy_net = self.policy_net.to(self.device)\n self.target_net = self.target_net.to(self.device)\n self.target_net.eval()\n self.optimizer = optim.Adam(self.policy_net.parameters(), lr=0.0001)\n self.memory = ReplayMemory(memory_size)\n self.batch_size = batch_size\n self.gamma = gamma\n self.target_update = target_update_frequency\n self.steps_done = 0\n self.episodes_done = 0\n self.episode_rewards = []\n self.episode_lengths = []\n self.saving_dir = saving_dir\n\n self.state = None","def optimizerFactory(hybridModel, params):\n\n if params['optim']['name'] == 'adam':\n return torch.optim.Adam(\n hybridModel.parameters(),lr=params['optim']['lr'], \n betas=(0.9, 0.999), eps=1e-08, \n weight_decay=params['optim']['weight_decay'], amsgrad=False\n )\n elif params['optim']['name'] == 'sgd': \n return torch.optim.SGD(\n hybridModel.parameters(), lr=params['optim']['lr'], \n momentum=params['optim']['momentum'], weight_decay=params['optim']['weight_decay']\n )\n \n else:\n raise NotImplemented(f\"Optimizer {params['optim']['name']} not implemented\")","def add_optimizer(self, optimizer):\n assert isinstance(optimizer, torch.optim.Optimizer)\n setattr(self, 'optimizer', optimizer)","def fetch_optimizer(args, model):\n optimizer = optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.wdecay, eps=args.epsilon)\n\n scheduler = optim.lr_scheduler.OneCycleLR(optimizer, args.lr, args.num_steps + 100,\n pct_start=0.05, cycle_momentum=False, anneal_strategy='linear')\n\n return optimizer, scheduler","def _create_model(self):\n if torch.cuda.is_available():\n model = torch.jit.load(self.torch_jit).cuda()\n else:\n model = torch.jit.load(self.torch_jit)\n model.eval()\n return model","def __init__(self, model: torch.nn.Module) -> None:\n self.model = copy.deepcopy(model)\n self.model.eval().to(device=DEVICE)\n self.rule_layer_map: List[Tuple[List[str], rules.LrpRule,\n Dict[str, Union[torch.Tensor, float]]]] = []\n self.input_nchw: Optional[torch.Tensor] = None\n self.label_idx_n: Optional[torch.Tensor] = None\n self.relevance_scores_nchw: Optional[torch.Tensor] = None\n self.explained_class_indices: Optional[torch.Tensor] = None","def create_optimizer(self, context, optimizer, host):\n pass","def create_optimizer(parameters, optimizer_class, optim_params, model_name='model'):\n opt = optimizer_class(parameters, **optim_params)\n if special_parameters.load_model:\n _load_optimizer(opt, model_name)\n return opt","def define_model_and_optimizer(self):\r\n print(\"* Defining model and optimizer.\", flush=True)\r\n job_dir = self.C.job_dir\r\n\r\n if self.C.restart:\r\n print(\"-- Loading model from previous saved state.\", flush=True)\r\n self.restart_epoch = util.get_restart_epoch()\r\n self.model = torch.load(f\"{job_dir}model_restart_{self.restart_epoch}.pth\")\r\n\r\n print(\r\n f\"-- Backing up as \"\r\n f\"{job_dir}model_restart_{self.restart_epoch}_restarted.pth.\",\r\n flush=True,\r\n )\r\n shutil.copyfile(\r\n f\"{job_dir}model_restart_{self.restart_epoch}.pth\",\r\n f\"{job_dir}model_restart_{self.restart_epoch}_restarted.pth\",\r\n )\r\n\r\n else:\r\n print(\"-- Initializing model from scratch.\", flush=True)\r\n self.model = models.initialize_model()\r\n\r\n self.restart_epoch = 0\r\n\r\n start_epoch = self.restart_epoch + 1\r\n end_epoch = start_epoch + self.C.epochs\r\n\r\n print(\"-- Defining optimizer.\", flush=True)\r\n self.optimizer = torch.optim.Adam(\r\n params=self.model.parameters(),\r\n lr=self.C.init_lr,\r\n weight_decay=self.C.weight_decay,\r\n )\r\n\r\n return start_epoch, end_epoch","def _build_model(self, model):\n model = model(self.state_dim, n_actions=self.n_actions)\n model.compile(loss=self._huber_loss,\n optimizer=optimizers.Adam(lr=self.learning_rate))\n return model","def __init__(self, model_name='vgg16'):\n trainer = Trainer(model_name=model_name)\n self.model = trainer.model\n self.model_save_dir = trainer.model_save_dir\n self.model_name = model_name","def get_adv_optimizer(self, mode: str) -> torch.optim.Optimizer:\n pass","def get_optimizer(cfg, model_parameters):\r\n op_params = cfg.copy()\r\n del op_params['name']\r\n\r\n optimizer = {\r\n 'sgd': torch.optim.SGD,\r\n 'adam': torch.optim.Adam\r\n }[cfg.name]\r\n return optimizer(model_parameters, **op_params)","def create_engine(model, optimizer, loss, device):\n model.to(device)\n\n def _update(engine, batch):\n data, label = batch\n num_channels = 1 if len(data.shape) == 2 else data.shape[1]\n data = data.view(-1, 1, data.shape[-1])\n data = data.to(device)\n label = label.to(device)\n label = label.float()\n\n model.train()\n model.zero_grad()\n optimizer.zero_grad()\n\n output = model(data)\n output = output.view(-1, num_channels, output.shape[-1])\n _loss = loss(output, label)\n _loss.backward()\n optimizer.step()\n\n return _loss.item()\n\n return Engine(_update)","def run_onnx_optimizer(onnx_model):\n try:\n onnx_polish_model = onnx.utils.polish_model\n except AttributeError:\n pass\n else:\n return onnx_polish_model(onnx_model)\n\n try:\n # pylint: disable=import-outside-toplevel\n import onnxoptimizer\n except ImportError:\n pass\n else:\n return onnxoptimizer.optimize(onnx_model)\n\n return onnx_model","def __init__(self,\n model: Type[torch.nn.Module],\n optimizer: Type[optim.PyroOptim] = None,\n loss: Type[infer.ELBO] = None,\n enumerate_parallel: bool = False,\n seed: int = 1,\n **kwargs: Union[str, float]\n ) -> None:\n pyro.clear_param_store()\n set_deterministic_mode(seed)\n self.device = kwargs.get(\n \"device\", 'cuda' if torch.cuda.is_available() else 'cpu')\n if optimizer is None:\n lr = kwargs.get(\"lr\", 1e-3)\n optimizer = optim.Adam({\"lr\": lr})\n if loss is None:\n if enumerate_parallel:\n loss = infer.TraceEnum_ELBO(\n max_plate_nesting=1, strict_enumeration_warning=False)\n else:\n loss = infer.Trace_ELBO()\n guide = model.guide\n if enumerate_parallel:\n guide = infer.config_enumerate(guide, \"parallel\", expand=True) \n self.svi = infer.SVI(model.model, guide, optimizer, loss=loss)\n self.loss_history = {\"training_loss\": [], \"test_loss\": []}\n self.current_epoch = 0","def __init__(self, model: Module, settings: PGActorSettings) -> None:\n super().__init__(settings)\n\n final_layer, self.network = finalize_module(model, from_numpy(self.state_space.sample()),\n self._num_policy_params)\n self.settings.optimizer.add_param_group({\"params\": final_layer.parameters()})","def __init__(self, name, model, log_dir, lr, lr_decay_step, adam=False):\n\t\tsuper(Trainer, self).__init__(self.update_model)\n\t\tself.model = model\n\t\t# tqdm\n\t\tProgressBar(persist=True).attach(self)\n\t\t# Optimizer\n\t\tparams = [p for p in model.parameters() if p.requires_grad]\n\t\tif adam:\n\t\t\tself.optimizer = torch.optim.Adam(params, lr=lr)\n\t\telse:\n\t\t\tself.optimizer = torch.optim.SGD(params, lr=lr, momentum=0.9)\n\t\t# Scheduler\n\t\tif lr_decay_step > 0:\n\t\t\tself.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=lr_decay_step, gamma=0.1)\n\t\t\tself.add_event_handler(Events.EPOCH_COMPLETED, lambda e: e.scheduler.step())\n\t\telse:\n\t\t\tself.scheduler = None\n\t\t# Terminate if nan values found\n\t\tself.add_event_handler(Events.ITERATION_COMPLETED, TerminateOnNan())\n\t\t# Tensorboard logging\n\t\tself.tb_logger = TensorboardLogger(log_dir=os.path.join(log_dir, name))\n\t\tself.add_event_handler(Events.COMPLETED, lambda x: self.tb_logger.close())\n\t\tself.tb_logger.attach(self,\n\t\t log_handler=OptimizerParamsHandler(self.optimizer),\n\t\t event_name=Events.EPOCH_COMPLETED)\n\t\tself.tb_logger.attach(self,\n\t\t log_handler=OutputHandler(tag='training', output_transform=lambda x: {\n\t\t\t 'rpn_box_loss': round(self.state.output['loss_rpn_box_reg'].item(), 4),\n\t\t\t 'rpn_cls_loss': round(self.state.output['loss_objectness'].item(), 4),\n\t\t\t 'roi_box_loss': round(self.state.output['loss_box_reg'].item(), 4),\n\t\t\t 'roi_cls_loss': round(self.state.output['loss_classifier'].item(), 4)\n\t\t }),\n\t\t event_name=Events.EPOCH_COMPLETED)\n\t\t# Run on GPU (cuda) if available\n\t\tif torch.cuda.is_available():\n\t\t\ttorch.cuda.set_device(int(get_free_gpu()))\n\t\t\tmodel.cuda(torch.cuda.current_device())","def __init__(self, model: Callable, q: Callable, loss: Callable,\n optimizer: jax_optim.Optimizer, initial_params: Dict):\n self.model = model\n self.q = q\n self.loss = loss\n self.optimizer = optimizer\n self.optimizer_state = self.optimizer.init_fn(initial_params)\n self.step = 0","def add_optimizer(self, optimizer):\n assert isinstance(optimizer, torch.optim.Optimizer)\n setattr(self, 'optimizer'+str(self._optimizer_counter), optimizer)\n self._optimizer_counter += 1\n # optimizer indexing : optimizer 0 is the optimizer for layer 0","def _create_optimizer(self):\n\n with tf.name_scope(\"optimizer\"):\n self.train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.loss)","def init_optimizer(network, config):\n # define optimizer and loss\n if config.optimizer == 'adadelta':\n opt = torch.optim.Adadelta(network.parameters(), lr=config.lr, weight_decay=config.weight_decay)\n elif config.optimizer == 'adam':\n opt = torch.optim.Adam(network.parameters(), lr=config.lr, weight_decay=config.weight_decay)\n elif config.optimizer == 'rmsprop':\n opt = torch.optim.RMSprop(network.parameters(), lr=config.lr, weight_decay=config.weight_decay)\n return opt","def make_optimizer(self):\r\n # parameters = [self.encoder.parameters(), self.decoder.parameters(), self.spec_enc.parameters()]\r\n if self.flags.optim == 'Adam':\r\n op = torch.optim.Adam(self.model.parameters(), lr=self.flags.lr, weight_decay=self.flags.reg_scale)\r\n elif self.flags.optim == 'RMSprop':\r\n op = torch.optim.RMSprop(self.model.parameters(), lr=self.flags.lr, weight_decay=self.flags.reg_scale)\r\n elif self.flags.optim == 'SGD':\r\n op = torch.optim.SGD(self.model.parameters(), lr=self.flags.lr, weight_decay=self.flags.reg_scale)\r\n else:\r\n raise Exception(\"Your Optimizer is neither Adam, RMSprop or SGD, please change in param or contact Ben\")\r\n return op","def build_model(self):\n self.global_step = tf.Variable(0, name=\"global_step\", trainable=False)\n\n if self.config.optimizer == 'sgd':\n self.optimizer = tf.keras.optimizers.SGD(learning_rate=self.config.learning_rate)\n elif self.config.optimizer == 'rms':\n self.optimizer = tf.keras.optimizers.RMSprop(learning_rate=self.config.learning_rate)\n elif self.config.optimizer == 'adam':\n self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate)\n elif self.config.optimizer == 'adagrad':\n self.optimizer = tf.keras.optimizers.Adagrad(learning_rate=self.config.learning_rate)\n elif self.config.optimizer == 'adadelta':\n self.optimizer = tf.keras.optimizers.Adadelta(learning_rate=self.config.learning_rate)\n else:\n raise NotImplementedError(\"No support for %s optimizer\" % self.config.optimizer)\n \n if self.config.optimizer in ['rms', 'adagrad', 'adadelta']:\n with tf.device('cpu:0'):\n self.model.def_parameters()\n else:\n self.model.def_parameters()\n\n self.config.summary()\n self.config.summary_hyperparameter(self.model.model_name)","def compile_optimizer(self):\n optimizer = torch.optim.Adam(self.parameters(), lr=self.cfg.learning_rate)\n\n return optimizer","def _inst_optimizer(self):\n optimizer = Optimizers(self.m_cfg['configs']['lr_politics']['optimizer']).value\n lr_schedule = self.m_cfg['configs']['lr_politics']['lr']\n opt = optimizer(learning_rate=lr_schedule)\n return opt","def create_optimizer(net, optimizer_state_dict, learning_rate, device='cuda'):\n # define optimizer\n optimizer = optim.Adam([{\n 'params': net.net.parameters(),\n 'initial_lr': learning_rate\n }])\n # load optimizer checkpoint if available\n if optimizer_state_dict is not None:\n target_device = 'cpu' if device == 'cpu' else 'cuda'\n # load the optimizer weights\n optimizer.load_state_dict(optimizer_state_dict)\n for state in optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = getattr(v, target_device)()\n return optimizer","def init_optimizer_for_pruning(cls, optimizer):\n assert (cls.__optimizer is None), \"ASP has initialized optimizer already.\"\n assert (cls.__calculate_mask is not None), \"Called ASP.init_optimizer_for_pruning before ASP.init_model_for_pruning.\"\n\n # store pointer to original optimizer step method\n cls.__optimizer = optimizer\n cls.__optimizer.__step = optimizer.step\n\n def __step(opt_self, *args, **kwargs):\n # prune gradients before step method\n with torch.no_grad():\n for module_name, module, p_name, p, mask, pruned in cls.__sparse_parameters:\n p.grad.mul_(mask)\n # call original optimizer step method\n rval = opt_self.__step(*args, **kwargs)\n # prune parameters after step method\n with torch.no_grad():\n for module_name, module, p_name, p, mask, pruned in cls.__sparse_parameters:\n p.mul_(mask)\n return rval\n cls.__optimizer.step = types.MethodType(__step, cls.__optimizer)","def get_optimizer(self, optimizer, params):\n # Reference: https://pytorch.org/docs/stable/optim.html#per-parameter-options\n optimizer = getattr(optim, optimizer, \"Adam\")(\n [\n {'params': self.shared_conv.parameters()},\n {'params': self.detector.parameters()},\n # {'params': self.recognizer.parameters()},\n ],\n **params\n )\n\n return optimizer","def _get_optim(\n self,\n model: nn.Module,\n optim_class: Type[torch.optim.Optimizer],\n multi_tensor: bool,\n ) -> torch.optim.Optimizer:\n param_groups = self._get_param_groups(model)\n return optim_class(param_groups, lr=5e-3, foreach=multi_tensor)","def __init__(self, model: Editable, loss_function, error_function=classification_error, opt=None,\n stability_coeff=0.01, editability_coeff=0.01, max_norm=None, **kwargs):\n opt = opt if opt is not None else torch.optim.Adam(model.parameters())\n super().__init__(model, loss_function=loss_function, opt=opt, error_function=error_function, **kwargs)\n self.stability_coeff, self.editability_coeff, self.max_norm = stability_coeff, editability_coeff, max_norm","def __init__(self, *, model, criterion, optimizer, dataloader, logdir='.', storage='storage.hdf5',\n transformation=lambda x: x, loss_decay=0.95, split_sample=None):\n\n self.model = model\n self.criterion = criterion\n self.optimizer = optimizer\n self.dataloader = dataloader\n self.logdir = logdir\n self.storage = os.path.join(logdir, storage) if storage is not None else None\n self.transformation = transformation\n self.cuda = bool(next(model.parameters()).is_cuda)\n self.dtype = next(model.parameters()).dtype\n self.loss_decay = loss_decay\n self.epochs = 0\n self.steps = 0\n self.split_sample = split_sample if callable(split_sample) else self._split_sample\n\n # register base handlers\n self.events = {event: [] for event in events.event_list}\n self.register_event_handler(events.AFTER_TRAINING, self.save, directory=self.logdir)\n self.register_event_handler(events.AFTER_TRAINING, self.close_storage)\n self.register_event_handler(events.EACH_STEP, TrainingLoss(), monitor=(storage is not None))\n\n super().__init__()\n\n # unify backward call for all types of optimizer\n if not hasattr(self.optimizer, 'backward'):\n setattr(self.optimizer, 'backward', self._backward)","def __init__(self, state_dim, action_dim, learning_rate, weight_decay):\n self.dynamics_net = ForwardModel(state_dim, action_dim)\n self.rewards_net = RewardModel(state_dim, action_dim)\n self.done_net = RewardModel(state_dim, action_dim)\n\n self.dyn_optimizer = tfa_optimizers.AdamW(\n learning_rate=learning_rate, weight_decay=weight_decay)\n self.reward_optimizer = tfa_optimizers.AdamW(\n learning_rate=learning_rate, weight_decay=weight_decay)\n self.done_optimizer = tfa_optimizers.AdamW(\n learning_rate=learning_rate, weight_decay=weight_decay)","def inject(self, model):\n if not hasattr(model, 'train_function'):\n raise RuntimeError('You must compile your model before using it.')\n\n model._check_trainable_weights_consistency()\n\n if model.train_function is None:\n inputs = (model._feed_inputs +\n model._feed_targets +\n model._feed_sample_weights)\n if model._uses_dynamic_learning_phase():\n inputs += [K.learning_phase()]\n fast_params = model._collected_trainable_weights\n\n with K.name_scope('training'):\n with K.name_scope(model.optimizer.__class__.__name__):\n training_updates = model.optimizer.get_updates(\n params=fast_params,\n loss=model.total_loss)\n slow_params = [K.variable(p) for p in fast_params]\n fast_updates = (model.updates +\n training_updates +\n model.metrics_updates)\n\n slow_updates, copy_updates = [], []\n for p, q in zip(fast_params, slow_params):\n slow_updates.append(K.update(q, q + self.alpha * (p - q)))\n copy_updates.append(K.update(p, q))\n\n # Gets loss and metrics. Updates weights at each call.\n fast_train_function = K.function(\n inputs,\n [model.total_loss] + model.metrics_tensors,\n updates=fast_updates,\n name='fast_train_function',\n **model._function_kwargs)\n\n def F(inputs):\n self.count += 1\n R = fast_train_function(inputs)\n if self.count % self.k == 0:\n K.batch_get_value(slow_updates)\n K.batch_get_value(copy_updates)\n return R\n\n #### REM : C'est pas super propre ca comme manière de faire\n #### Tu rompts l'encapsulation de la classe \n model.train_function = F","def get_unet_model(self):\n # create optimizer instance\n config = {\n 'class_name': self.optimizer,\n 'config': self.optimizer_params}\n optimizer = get_optimizer(config)\n\n self.model = unet(optimizer=optimizer,\n loss=self.loss,\n metrics=self.metrics,\n input_size=self.input_size,\n pretrained_weights=self.pretrained_weights)","def set_lr(model: Union[tf.keras.Model, torch.nn.Module], lr: float, weight_decay: Optional[float] = None):\n assert hasattr(model, \"fe_compiled\") and model.fe_compiled, \"set_lr only accept models from fe.build\"\n if isinstance(model, tf.keras.Model):\n # when using decoupled weight decay like SGDW or AdamW, weight decay factor needs to change together with lr\n # see https://www.tensorflow.org/addons/api_docs/python/tfa/optimizers/DecoupledWeightDecayExtension for detail\n if isinstance(model.current_optimizer, tfa.optimizers.DecoupledWeightDecayExtension) or hasattr(\n model.current_optimizer, \"inner_optimizer\") and isinstance(\n model.current_optimizer.inner_optimizer, tfa.optimizers.DecoupledWeightDecayExtension):\n if weight_decay is None:\n weight_decay = tf.keras.backend.get_value(model.current_optimizer.weight_decay) * lr / get_lr(model)\n tf.keras.backend.set_value(model.current_optimizer.weight_decay, weight_decay)\n tf.keras.backend.set_value(model.current_optimizer.lr, lr)\n elif isinstance(model, torch.nn.Module):\n for param_group in model.current_optimizer.param_groups:\n param_group['lr'] = lr\n else:\n raise ValueError(\"Unrecognized model instance {}\".format(type(model)))","def setup_optims(self):\n lr = self.train_config['lr']\n b1 = self.train_config['b1']\n b2 = self.train_config['b2']\n weight_decay = self.train_config['weight_decay']\n self.opt = torch.optim.Adam(self.network.parameters(), lr=lr, betas=(b1, b2),\n weight_decay=weight_decay)","def __init__(self,\n model=None,\n train_dataset=None,\n eval_dataset=None,\n optimizer=None,\n criterion=None,\n cpu: bool = False):\n\n # import torch for initialization\n torch = import_optional_dependency(\"torch\")\n\n # ============== basic parameters ============== #\n # the device that used to train models, which can automatically set\n self.device = torch.device(\"cuda\" if torch.cuda.is_available() and not cpu else \"cpu\")\n # the optimizer of training\n self.optimizer = optimizer\n # the neural network model\n self.model = model.to(self.device) if model else None\n # the criterion of training\n self.criterion = criterion.to(self.device) if criterion else None\n # the dataset for training\n self.train_dataset = train_dataset\n # the dataset for evaluation\n self.eval_dataset = eval_dataset\n # the training process would show information if self.info is True\n self.info = True\n\n # ============== the parameters of training ============== #\n # the loss average meter for every epoch\n self.epoch_loss = AverageMeter()\n # the counter for training\n self.epoch = 0\n # training process for iteration\n self.batch_process = None","def __init__(self, conf):\n self.model_conf = conf[\"model\"]\n self.epochs = self.model_conf.getint(\"n_epochs\")\n self.epoch = self.model_conf.getint(\"epoch_start\")\n self.batch_size = self.model_conf.getint(\"batch_size\")\n self.criterion = nn.CrossEntropyLoss()\n self.device = torch.device(self.model_conf.get('device'))\n #self.model = (\n # eval(self.model_conf.get('name'))(self.model_conf).to(self.device)\n #)\n self.model = nn.DataParallel(\n eval(self.model_conf.get('name'))(self.model_conf).to(self.device)\n )\n total_params = sum(p.numel() for p in self.model.parameters())\n print(\"Created model {}: {} parameters\"\n .format(self.model_conf.get('name'), total_params))\n if self.model_conf.get(\"optim\") == 'SGD':\n self.optimizer = optim.SGD(\n self.model.parameters(),\n lr=self.model_conf.getfloat(\"learning_rate\"),\n momentum=self.model_conf.getfloat(\"momentum\"),\n weight_decay=self.model_conf.getfloat(\"weight_decay\"))\n elif self.model_conf.get(\"optim\") == 'Adam':\n self.optimizer = optim.Adam(\n self.model.parameters(),\n lr=self.model_conf.getfloat(\"learning_rate\"),\n betas=json.loads(self.model_conf.get(\"betas\")))\n else:\n raise ValueError('Only SGD is supported')\n\n if self.model_conf.get(\"checkpoint\") is not None:\n self.load_checkpoint(self.model_conf.get(\"checkpoint\"))\n\n self.checkpoints_path = conf.get(\"paths\", \"checkpoints\")\n self.results_path = conf.get(\"paths\", \"results\")\n self.best_accuracy = 0\n self.train_size = None\n self.valid_size = None\n self.iteration_print_freq = conf.getint(\"log\", \"iteration_print_freq\")","def convert_to_torch_amp(model: nn.Module,\n optimizer: Optimizer,\n criterion: Optional[_Loss] = None,\n amp_config: Optional[Config] = None):\n model = TorchAMPModel(model)\n if amp_config is None:\n amp_config = dict()\n optimizer = TorchAMPOptimizer(optimizer, **amp_config)\n if criterion:\n criterion = TorchAMPLoss(criterion)\n return model, optimizer, criterion","def __init__(self):\n \n self.model = Net()\n\n if torch.cuda.is_available():\n map_location=torch.device('cuda')\n else:\n map_location=torch.device('cpu')\n\n # load parameters\n self.model.load_state_dict(torch.load('model.pt',\n map_location=map_location)) \n \n if torch.cuda.is_available():\n self.model.cuda()\n else:\n self.model.cpu()\n \n self.model.eval()","def __init__(\n self,\n model: nn.Module,\n branch_losses: Dict[str, int],\n branch_loss_params: Dict[str, Dict[str, Any]] = None,\n branch_metrics: Dict[str, List[str]] = None,\n optimizer: str = \"adam\",\n lookahead: bool = False,\n optim_params: Dict[str, Dict[str, Any]] = None,\n scheduler: str = \"reduce_on_plateau\",\n scheduler_params: Dict[str, Any] = None,\n log_freq: int = 100,\n **kwargs,\n ) -> None:\n super().__init__()\n self.model = model\n self.heads = model.heads\n self.aux_key = model.aux_key\n self.inst_key = model.inst_key\n\n self.optimizer = optimizer\n self.optim_params = optim_params\n self.scheduler = scheduler\n self.scheduler_params = scheduler_params\n self.lookahead = lookahead\n\n self.branch_losses = branch_losses\n self.branch_metrics = branch_metrics\n self.branch_loss_params = branch_loss_params\n self.log_freq = log_freq\n\n self._validate_branch_args()\n self.save_hyperparameters(ignore=\"model\")\n\n self.criterion = self.configure_loss()\n metrics = self.configure_metrics()\n self.train_metrics = deepcopy(metrics)\n self.val_metrics = deepcopy(metrics)\n self.test_metrics = deepcopy(metrics)","def load_model(model_path: str) -> object:\n model = torch.load(model_path)\n model.eval()\n return model","def _make_model(self):\n self._model = tf.estimator.Estimator(model_fn=self.model_fn,\n model_dir=self.model_dir,\n config=self._config,\n params=self._params,\n )","def optimizer_setup(optimizer_class: Type[torch.optim.Optimizer], **hyperparameters) -> \\\n Callable[[torch.nn.Module], torch.optim.Optimizer]:\n\n def f(model):\n return optimizer_class(model.parameters(), **hyperparameters)\n\n return f","def setup_trainer(model, train_dir, train_loader, val_loader,\n property_map, exclude=[]):\n hooks = build_hooks(train_dir=train_dir, property_map=property_map)\n\n trainable_params = filter(lambda p: p.requires_grad, model.parameters())\n trainable_params = filter(lambda p: p not in exclude, trainable_params)\n\n optim = build_optimizer(trainable_params=trainable_params)\n loss_fn = build_loss(property_map=property_map)\n trainer = Trainer(train_dir, model, loss_fn, optim, train_loader,\n val_loader, hooks=hooks)\n return trainer","def model_creator(config):\n return nn.Linear(1, 1)","def setup_optimizer(params, config):\n if config.METHOD == 'AdaMod':\n return AdaMod(params,\n lr=config.LR,\n betas=(config.BETA, 0.999),\n beta3=config.BETA3,\n weight_decay=config.WD)\n elif config.METHOD == 'Adam':\n return torch.optim.Adam(params,\n lr=config.LR,\n betas=(config.BETA, 0.999),\n weight_decay=config.WD)\n elif config.METHOD == 'SGD':\n return torch.optim.SGD(params,\n lr=config.LR,\n momentum=config.MOMENTUM,\n dampening=config.DAMPENING,\n weight_decay=config.WD,\n nesterov=config.NESTEROV)\n else:\n raise NotImplementedError","def get_optimizer(model, learning_rate, name=\"SGD\"):\n \n optimizer_dict = {\"SGD\": optim.SGD(model.parameters(), lr=learning_rate,\n weight_decay=0.0001, momentum=0.9),\n \"Adam\": optim.Adam(model.parameters(), lr=learning_rate,\n weight_decay=0.0001),\n \"RMSProp\": optim.RMSprop(model.parameters(), lr=learning_rate,\n weight_decay=0.0001)}\n return optimizer_dict[name]","def __init__(self,\n verbosity=1,\n model=None,\n path=None,\n prefix=None,\n **kwargs):\n if K.BACKEND == 'tensorflow' and tf is not None:\n min_version = tf.__version__.split(\".\")[1]\n maj_version = tf.__version__.split(\".\")[0]\n if maj_version in [\"2\"] and min_version in [\"3\", \"4\"]:\n raise NotImplementedError(f\"\"\"\n Not implemented due to a bug in tensorflow as shown here https://github.com/tensorflow/tensorflow/issues/44646\n You can use functional API instead by using\n from ai4water.functional import Model\n instead of \n from ai4water import Model\n Or change the tensorflow version. Current version is {tf.__version__}. \n \"\"\")\n\n tf_kwargs = {}\n for arg in ['inputs', 'outputs']:\n if arg in kwargs:\n tf_kwargs[arg] = kwargs[arg]\n\n self._go_up = False\n\n MODEL.__init__(self, **tf_kwargs)\n\n self._go_up = True\n BaseModel.__init__(self,\n prefix=prefix,\n path=path,\n verbosity=verbosity,\n model=model,\n **kwargs)\n\n self.config['backend'] = K.BACKEND\n\n if torch is not None:\n from .models._torch import Learner\n self.torch_learner = Learner(\n model=self,\n batch_size=self.config['batch_size'],\n num_epochs=self.config['epochs'],\n shuffle=self.config['shuffle'],\n to_monitor=self.config['monitor'],\n patience=self.config['patience'],\n path=self.path,\n use_cuda=False,\n wandb_config=self.config['wandb_config'],\n verbosity=self.verbosity\n )\n\n if self.category == \"DL\":\n self.initialize_layers(self.config['model']['layers'])\n\n if K.BACKEND == 'tensorflow':\n outs = self.call(self._input_lyrs(), run_call=False)\n setattr(self, 'output_lyrs', outs)\n self._go_up = False # do not reinitiate BaseModel and other upper classes\n\n maj_ver = int(tf.__version__.split('.')[0])\n min_ver = int(tf.__version__.split('.')[1][0])\n # in tf versions >= 2.5, we don't need to specify inputs and outputs as keyword arguments\n if maj_ver>1 and min_ver>=5:\n MODEL.__init__(self, self._input_lyrs(), self.output_lyrs)\n else:\n MODEL.__init__(self, inputs=self._input_lyrs(), outputs=self.output_lyrs)\n\n self.build(self._get_dummy_input_shape()) # will initialize ML models or build NNs","def train(model, optimizer: torch.optim, data: torch_geometric.data.Data):\n model.train()\n optimizer.zero_grad()\n F.nll_loss(model()[data.train_mask], data.y[data.train_mask]).backward()\n optimizer.step()\n\n model.eval()","def __init__(self, model):\n self.output_weights = model.get_layer(\"output\").get_weights()[0]\n self.cam_model = Model(inputs=model.input, outputs=(model.get_layer(\"activation\").output, model.get_layer(\"output\").output))","def __init__(self,\n forward_models,\n forward_model_optim=tf.keras.optimizers.Adam,\n forward_model_lr=0.001):\n\n super().__init__()\n self.forward_models = forward_models\n self.bootstraps = len(forward_models)\n\n # create optimizers for each model in the ensemble\n self.forward_model_optims = [\n forward_model_optim(learning_rate=forward_model_lr)\n for i in range(self.bootstraps)]","def create_custom_supervised_trainer(model, optimizer, loss_fn, metrics={}, device=None, prepare_batch=None):\n\n def _update(engine, batch):\n model.train()\n optimizer.zero_grad()\n if not prepare_batch:\n x, y = _prepare_batch(batch, device=device)\n else:\n x, y = prepare_batch(batch, device=device)\n y_pred = model(x)\n loss = loss_fn(y_pred, y)\n loss.backward()\n optimizer.step()\n return loss.item(), y_pred, y\n\n def _metrics_transform(output):\n return output[1], output[2]\n\n engine = Engine(_update)\n\n for name, metric in metrics.items():\n metric._output_transform = _metrics_transform\n metric.attach(engine, name)\n\n return engine","def model_compile(self, model, optimiser, loss, metrics, learning_rate = None):\n\n if optimiser == \"sgd\":\n model.compile(optimizer = SGD(lr = learning_rate),\n loss = loss, metrics = metrics)\n elif optimiser == \"rmsprop\":\n model.compile(optimizer = RMSprop(lr = learning_rate),\n loss = loss, metrics = metrics)\n else:\n model.compile(optimizer = optimiser, loss = loss,\n metrics = metrics)","def get_optimizer(model, lr_method, lr_rate):\n lr_method_name = lr_method\n\n # initialize optimizer function\n if lr_method_name == 'sgd':\n optimizer = optim.SGD(model.parameters(), lr=lr_rate, momentum=0.9)\n # scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)\n elif lr_method_name == 'adagrad':\n optimizer = optim.Adagrad(model.parameters(), lr=lr_rate)\n # scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)\n elif lr_method_name == 'adam':\n optimizer = optim.Adam(model.parameters(), lr=lr_rate)\n # scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.001)\n else:\n raise Exception('unknown optimization method.')\n\n return optimizer # , scheduler","def _set_optimizer(self):\n\n if self.optimizer_name == 'Adam':\n self.optimizer = optim.Adam(self.net.parameters(),\n lr=self.learning_rate,\n betas=self.betas,\n eps=1e-8,\n weight_decay=self.weight_decay)\n elif self.optimizer_name == 'SGD':\n self.optimizer = optim.SGD(self.net.parameters(),\n lr=self.learning_rate,\n momentum=self.momentum,\n weight_decay=self.weight_decay)\n elif self.optimizer_name == 'SGD_Nesterov':\n self.optimizer = optim.SGD(self.net.parameters(),\n lr=self.learning_rate,\n momentum=self.momentum,\n weight_decay=self.weight_decay,\n nesterov=True)\n elif self.optimizer_name == 'RMSprop':\n self.optimizer = optim.Adagrad(self.net.parameters(),\n lr=self.learning_rate,\n momentum=self.momentum,\n weight_decay=self.weight_decay)\n elif self.optimizer_name == 'Adagrad':\n self.optimizer = optim.Adagrad(self.net.parameters(),\n lr=self.learning_rate,\n weight_decay=self.weight_decay)\n else:\n print(\"Optimizer '\" + self.optimizer_name + \"' not implemented.\")","def __init__(self, model_path: str = None):\n\n self.img_size = 128\n self.tranform = transforms.Compose(\n [transforms.Resize((self.img_size, self.img_size)), transforms.ToTensor()]\n )\n if model_path:\n self.__load_model(path=model_path)\n else:\n print(\"Provide a path to trained model!\")","def add_optimizer(self):\n \n with tf.variable_scope(\"optimizer\"):\n\n # Define optimizer and minimize loss\n if self.OPTIM == \"RMSProp\":\n self.optimizer = tf.train.RMSPropOptimizer(self.LEARN_RATE).\\\n minimize(self.cost)\n \n elif self.OPTIM == \"GD\":\n self.optimizer = tf.train.GradientDescentOptimizer(self.LEARN_RATE).\\\n minimize(self.cost)\n \n elif self.OPTIM == \"Adam\":\n self.optimizer = tf.train.AdamOptimizer(self.LEARN_RATE).\\\n minimize(self.cost)\n\n # Merge all summaries for tensorboard\n #self.tbsummaries = tf.summary.merge_all()","def get_task_optimizer(self) -> torch.optim.Optimizer:\n pass","def __init__(self,\n model: PreTrainedModel,\n tokenizer: PreTrainedTokenizer,\n optimizer: torch.optim.Optimizer,\n n_epochs: int,\n labels2ind: Dict[str, int],\n scheduler: Optional[torch.optim.lr_scheduler.LambdaLR] = None,\n device: str = 'cpu',\n clipping: Optional[Union[int, float]] = None,\n accumulate_grad_every: int = 1,\n print_every: int = 10,\n print_val_mistakes: bool = False,\n output_dir: str = './'):\n\n self.tokenizer = tokenizer\n self.model = model\n self.optimizer = optimizer\n self.scheduler = scheduler\n self.n_epochs = n_epochs\n self.labels2ind = labels2ind\n self.inds2labels = {v: k for k, v in self.labels2ind.items()}\n self.device = device\n self.clipping = clipping\n self.accumulate_grad_every = accumulate_grad_every\n self.print_every = print_every\n self.print_val_mistakes = print_val_mistakes\n self.output_dir = output_dir\n\n os.makedirs(self.output_dir, exist_ok=True)","def get_optimizer(train_model, params):\n # TODO: Why are we looking for an entry in a list instead of directly matching the string?\n if params.optimizer in [\"adam\"]:\n param_optimizer = list(train_model.named_parameters())\n # Set weight decay of bias and LayerNorm.weight to zero.\n param_optimizer = [n for n in param_optimizer if 'pooler' not in n[0]]\n no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n\n optimizer_grouped_parameters = [\n {'params': [p for n, p in param_optimizer if not any(\n nd in n for nd in no_decay)], 'weight_decay': 0.01},\n {'params': [p for n, p in param_optimizer if any(\n nd in n for nd in no_decay)], 'weight_decay': 0.0}\n ]\n\n if params.fp16:\n print(\"SystemLog: Loading Apex and building the FusedAdam optimizer.\")\n try:\n from apex import amp\n from apex.optimizers import FusedAdam\n from apex.amp import _amp_state\n except:\n raise ImportError(\n \"SystemLog: Please install apex from https://www.github.com/nvidia/apex to use distributed and fp16 training.\")\n\n if params.amp_opt_lvl not in ['O0', 'O1', 'O2', 'O3']:\n raise ValueError(\"SystemLog: %s amp_opt_level is not supported\" % params.amp_opt_lvl)\n\n print(\"SystemLog: Using %s opt_level for Amp\" % params.amp_opt_lvl)\n\n optimizer = FusedAdam(optimizer_grouped_parameters,\n lr=params.learning_rate,\n bias_correction=False)\n if params.loss_scale == 0:\n train_model, optimizer = amp.initialize(train_model, optimizer, opt_level=params.amp_opt_lvl, loss_scale=\"dynamic\")\n else:\n train_model, optimizer = amp.initialize(train_model, optimizer, opt_level=params.amp_opt_lvl, loss_scale=params.loss_scale)\n amp._amp_state.loss_scalers[0]._loss_scale = 2**20\n else:\n optimizer = BertAdam(optimizer_grouped_parameters,\n lr=params.learning_rate,\n warmup=params.warmup_proportion,\n t_total=params.total_training_steps)\n else:\n # TODO: These parameters should be made configurable through global parameters/function arguments\n optimizer = torch.optim.Adadelta(train_model.parameters(), lr=params.learning_rate, rho=0.95, eps=1e-08, weight_decay=0)\n\n return train_model, optimizer","def get_optimizer(start_epoch, factor, opt_config, model):\n optimizer = __optimizers[opt_config['optimizer']]\n opt_params = {'parameter_list': model.parameters()}\n for key in opt_config.keys():\n if key == 'learning_rate':\n lr = opt_config[key]\n bo = [val*factor for val in lr['bound']]\n decay_lr = fluid.dygraph.PiecewiseDecay(bo, lr['value'], start_epoch*factor)\n opt_params['learning_rate'] = decay_lr\n elif key == 'weight_decay':\n regularization = fluid.regularizer.L2Decay(regularization_coeff=opt_config[key])\n opt_params['regularization'] = regularization\n elif key == 'momentum':\n opt_params['momentum'] = opt_config[key]\n\n return optimizer(**opt_params)","def load_model(model_name, environment_name):\n ray.init(ignore_reinit_error=True)\n # Fetch the specified model trainer.\n model_module = importlib.import_module(\n \"ray.rllib.agents.\" + alg2module[model_name])\n # Load the trainer and return.\n trainer = getattr(model_module, model_name + 'Trainer')\n\n env = None\n if type(environment_name) == str:\n if \"MiniGrid\" in environment_name:\n import gym_minigrid.wrappers as gmw\n # Need to adjust observation space.\n minigrid_env = gym.make(environment_name)\n env = gmw.ImgObsWrapper(minigrid_env)\n else:\n env = gym.make(environment_name)\n else:\n env = environment_name\n\n return trainer(env=environment_name)","def configure_optimizers(self):\n optimizer = torch.optim.Adam(\n self.parameters(),\n lr=self.hparams.learning_rate,\n weight_decay=self.hparams.weight_decay,\n )\n return optimizer","def new(self):\n self.define_layers()\n self.model = nn.Sequential(*self.layers)\n self.model.cuda()\n self.model = orthogonal_init(self.model)\n\n # Re-count N\n self.count_params()","def convert_to_torch_script(model, input_size):\n model.eval()\n\n # An example input you would normally provide to your model's forward() method.\n example = torch.rand(1, 3, input_size, input_size)\n\n # Use torch.jit.trace to generate a torch.jit.ScriptModule via tracing.\n traced_script_module = torch.jit.trace(model, example)\n\n return traced_script_module","def train(train_loader : torch.utils.data.DataLoader, model : nn.Module, criterion : nn.Module, optimizer : torch.optim.Optimizer) -> logger.Result:","def set_optimizer(self, config):\r\n self.optimizer = optim.Adam(self.net.parameters(), config.lr)\r\n self.scheduler = optim.lr_scheduler.ExponentialLR(self.optimizer, config.lr_decay)","def load_model(model: nn.Module, model_args: dict, model_weights: str, device: torch.device):\n model = model(**model_args)\n state_dict = torch.load(model_weights, map_location=device)\n model.load_state_dict(state_dict[\"model\"])\n return model","def load(model_path: str):\n model = torch.load(model_path)\n model.eval()\n return model","def __init__(\n self, weights_path: Optional[str], max_frames: int = 0, **model_kwargs,\n ):\n super().__init__()\n max_frames = int(max_frames)\n if max_frames < 0:\n raise ValueError(f\"max_frames {max_frames} cannot be negative\")\n self.max_frames = max_frames\n self.model, self.optimizer = make_model(\n weights_path=weights_path, **model_kwargs\n )","def select_optimizer(opt, model):\n\n if opt == 'msgd':\n return optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n elif opt == 'adam':\n return optim.Adam(model.parameters(), lr=0.001)\n elif opt == 'rmsprop':\n return optim.RMSprop(model.parameters(), lr=0.001)\n elif opt == 'adagrad':\n return optim.Adagrad(model.parameters(), lr=0.001)\n else:\n return optim.SGD(model.parameters(), lr=0.001)","def _init_optimizer(self, optimizer):\n if optimizer == \"rmsprop\":\n self.optimizer = keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-06)\n elif optimizer == \"adagrad\":\n self.optimizer = keras.optimizers.Adagrad(lr=0.01, epsilon=1e-06)\n elif optimizer == \"adadelta\":\n self.optimizer = keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=1e-06)\n elif optimizer == \"adam\":\n self.optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\n elif optimizer == \"adamax\":\n self.optimizer = keras.optimizers.Adamax(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=1e-08) \n elif hasattr(optimizer, __call__):\n self.optimizer = optimizer\n else:\n print \"Error: unsupported optimizer %s\"%optimizer\n sys.exit(0)","def _init_optimizer(self, optimizer):\n if optimizer == \"rmsprop\":\n self.optimizer = keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-06)\n elif optimizer == \"adagrad\":\n self.optimizer = keras.optimizers.Adagrad(lr=0.01, epsilon=1e-06)\n elif optimizer == \"adadelta\":\n self.optimizer = keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=1e-06)\n elif optimizer == \"adam\":\n self.optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\n elif optimizer == \"adamax\":\n self.optimizer = keras.optimizers.Adamax(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=1e-08) \n elif hasattr(optimizer, __call__):\n self.optimizer = optimizer\n else:\n print \"Error: unsupported optimizer %s\"%optimizer\n sys.exit(0)","def optim_cls(self) -> type:\n\n return getattr(torch.optim, self._params.get(\"optimizer\", \"Adam\"))"],"string":"[\n \"def optimizer(self, model: nn.Module) -> torch.optim.Optimizer: # type: ignore\\n pass\",\n \"def build_optimizer(model: nn.Module, args: Namespace) -> Optimizer:\\n params = [{'params': model.parameters(), 'lr': args.init_lr, 'weight_decay': 0}]\\n\\n return Adam(params)\",\n \"def get_optimizer(args, model: torch.nn.Module):\\n return Adam(model.parameters(), lr=args.lr)\",\n \"def optimizer_creator(model, config):\\n return torch.optim.SGD(model.parameters(), lr=config.get(\\\"lr\\\", 1e-4))\",\n \"def __init__(self, model, optimizer=tf.compat.v1.train.AdamOptimizer, optimizer_arguments={}):\\n \\n self.model = model\\n self.train_optimizer = optimizer(**optimizer_arguments).minimize(self.model.trn_loss)\\n self.train_reg_optimizer = optimizer(**optimizer_arguments).minimize(self.model.reg_loss)\",\n \"def create_optimizer(optimizer_name, model, config):\\n if optimizer_name == 'adadelta':\\n return torch.optim.Adadelta(model.parameters(),\\n lr=config['adadelta_lr'],\\n rho=config['adadelta_rho'],\\n weight_decay=config['adadelta_weight_decay'],\\n eps=config['adadelta_eps'])\\n else:\\n raise Exception('Optimizer \\\\'{}\\\\' not supported.'.format(optimizer_name))\",\n \"def create_train_op(self, model, learning_rate):\\n if self.optim_type == 'adagrad':\\n optimizer = torch.optim.Adagrad(model.parameters(), lr=learning_rate, weight_decay=self.args.weight_decay)\\n elif self.optim_type == 'adadelta':\\n optimizer = torch.optim.Adadelta(model.parameters(), lr=learning_rate, weight_decay=self.args.weight_decay)\\n elif self.optim_type == 'adam':\\n optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=self.args.weight_decay)\\n elif self.optim_type == 'rprop':\\n optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate, weight_decay=self.args.weight_decay)\\n elif self.optim_type == 'sgd':\\n optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=self.args.momentum,\\n weight_decay=self.args.weight_decay)\\n else:\\n raise NotImplementedError('Unsupported optimizer: {}'.format(self.optim_type))\\n return optimizer\",\n \"def build_torch_optimizer(model, opt):\\n params = [p for p in model.parameters() if p.requires_grad]\\n if opt.optim == 'sgd':\\n optimizer = optim.SGD(params, lr=opt.learning_rate)\\n elif opt.optim == 'adagrad':\\n optimizer = optim.Adagrad(\\n params,\\n lr=opt.learning_rate,\\n initial_accumulator_value=opt.adagrad_accumulator_init)\\n elif opt.optim == 'adadelta':\\n optimizer = optim.Adadelta(params, lr=opt.learning_rate)\\n elif opt.optim == 'adam':\\n optimizer = optim.Adam(\\n params,\\n lr=opt.learning_rate,\\n betas=(opt.adam_beta1, opt.adam_beta2),\\n weight_decay=opt.learning_rate_decay,\\n eps=1e-9)\\n else:\\n raise ValueError('Invalid optimizer type: ' + opt.optim)\\n\\n return optimizer\",\n \"def get_optimizer(self, model):\\n optimizer = scaffold_optimizer.ScaffoldOptimizer(\\n model.parameters(),\\n lr=Config().trainer.learning_rate,\\n momentum=Config().trainer.momentum,\\n weight_decay=Config().trainer.weight_decay)\\n\\n optimizer.server_update_direction = self.server_update_direction\\n optimizer.client_update_direction = self.client_update_direction\\n optimizer.client_id = self.client_id\\n optimizer.update_flag = True\\n\\n return optimizer\",\n \"def create_model_optimizer(net,alpha):\\n optimizer = chainer.optimizers.Adam(alpha=alpha)\\n optimizer.setup(net)\\n return optimizer\",\n \"def create_optimizer(model: torch.nn.Module, optimizer_name: str, learning_rate: float, weight_decay: float = 0.0,\\n momentum: float = 0.0) -> torch.optim.Optimizer:\\n if optimizer_name.lower() == \\\"adadelta\\\":\\n optimizer = torch.optim.Adadelta(model.parameters(), learning_rate, weight_decay=weight_decay)\\n elif optimizer_name.lower() == \\\"adam\\\":\\n optimizer = torch.optim.Adam(model.parameters(), learning_rate, weight_decay=weight_decay)\\n elif optimizer_name.lower() == \\\"sgd\\\":\\n optimizer = torch.optim.SGD(model.parameters(), learning_rate, momentum,\\n weight_decay=weight_decay)\\n elif optimizer_name.lower() == \\\"rmsprop\\\":\\n optimizer = torch.optim.RMSprop(model.parameters(), learning_rate, weight_decay=weight_decay,\\n momentum=momentum)\\n else:\\n raise ValueError(\\\"SystemLog: The optimizer must be Adadelta, Adam, SGD, or RMSprop \\\"\\n \\\"(optimizer: {})\\\".format(optimizer_name))\\n\\n return optimizer\",\n \"def get_optimizer(model):\\n optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.5, 0.999))\\n return optimizer\",\n \"def optimizer_setup(model, params):\\n if params.optimizer == 'adam':\\n if params.freeze_backbone:\\n optimizer = optimizer_handler.layer_specific_adam(model, params)\\n else:\\n optimizer = optimizer_handler.plain_adam(model, params)\\n elif params.optimizer == 'sgd':\\n if params.freeze_backbone:\\n optimizer = optimizer_handler.layer_specific_sgd(model, params)\\n else:\\n optimizer = optimizer_handler.plain_sgd(model, params)\\n\\n if params.zero_bn_bias_decay:\\n optimizer = zero_wdcay_bn_bias(optimizer)\\n\\n return optimizer\",\n \"def initialize(self): \\n self.optimizer = torch.optim.Adam(self.model.parameters(), lr=config.LR)\",\n \"def optimizer_factory(config, model):\\n params = model.parameters()\\n\\n optimizer = config[\\\"loss\\\"].get(\\\"optimizer\\\", \\\"Adam\\\")\\n lr = config[\\\"loss\\\"].get(\\\"lr\\\", 1e-3)\\n momentum = config[\\\"loss\\\"].get(\\\"momentum\\\", 0.9)\\n\\n if optimizer == \\\"SGD\\\":\\n return optim.SGD(params, lr=lr, momentum=momentum)\\n elif optimizer == \\\"Adam\\\":\\n return optim.Adam(params, lr=lr)\\n else:\\n raise NotImplementedError()\",\n \"def make_optimizer(model, lr, opt, weight_decay):\\n optimizers = {\\n 'adam': optim.Adam,\\n 'adamax': optim.Adamax,\\n 'rmsprop': optim.RMSprop,\\n }\\n\\n optimizer = optimizers[opt](model.parameters(), lr=lr,\\n weight_decay=weight_decay)\\n\\n return optimizer\",\n \"def init_optimizer(model, config, exact_layers=None):\\n opt_type = config.optimizer\\n if exact_layers:\\n logger.info('Learning exact layers, number=%d', len(exact_layers))\\n parameters = []\\n for i, layer in enumerate(exact_layers):\\n if isinstance(layer, tuple) and len(layer) == 2:\\n layer, multiplier = layer\\n init_multiplier = 1\\n elif isinstance(layer, tuple) and len(layer) == 3:\\n layer, init_multiplier, multiplier = layer\\n else:\\n multiplier = 1\\n init_multiplier = 1\\n lr = config.lr * multiplier\\n init_lr = config.lr * multiplier * init_multiplier\\n logger.info('Layer=%d, lr=%.5f', i, init_lr)\\n parameters.append({'params': layer.parameters(), 'lr': init_lr, 'after_warmup_lr': lr})\\n else:\\n logger.info('Optimizing all parameters, lr=%.5f', config.lr)\\n parameters = model.parameters()\\n\\n if opt_type == 'sgd':\\n optimizer = torch.optim.SGD(parameters, config.lr, momentum=config.momentum, weight_decay=config.weight_decay)\\n elif opt_type == 'adam':\\n optimizer = torch.optim.Adam(parameters, lr=config.lr, weight_decay=config.weight_decay)\\n elif opt_type == 'yf':\\n optimizer = YFOptimizer(parameters, config.lr, mu=config.momentum, weight_decay=config.weight_decay,\\n clip_thresh=0.1)\\n else:\\n raise TypeError, 'Unknown optimizer type=%s' % (opt_type, )\\n return optimizer\",\n \"def __init__(self, model, adv_func, dist_func, attack_lr=1e-2,\\n init_weight=10., max_weight=80., binary_step=10, num_iter=500):\\n\\n self.model = model.cuda()\\n self.model.eval()\\n\\n self.adv_func = adv_func\\n self.dist_func = dist_func\\n self.attack_lr = attack_lr\\n self.init_weight = init_weight\\n self.max_weight = max_weight\\n self.binary_step = binary_step\\n self.num_iter = num_iter\",\n \"def create_optimizer(self, run_configuration, rng=None):\\n @functools.partial(jax.jit, static_argnums=(1, 2))\\n def create_model(rng, example, model_cls):\\n with flax.deprecated.nn.attention.Cache().mutate() as cache_def:\\n _, initial_params = model_cls.init(\\n rng,\\n example,\\n cache=cache_def)\\n model = flax.deprecated.nn.Model(model_cls, initial_params)\\n return model, cache_def\\n\\n config = self.config\\n dataset = run_configuration.dataset_info.dataset\\n\\n rng = rng if rng is not None else jax.random.PRNGKey(0)\\n learning_rate = config.opt.learning_rate\\n example = self.as_example(next(iter(dataset)))\\n model_cls = run_configuration.model\\n model, unused_cache_def = create_model(rng, example, model_cls)\\n return optimizer_utils.create_optimizer(model, learning_rate)\",\n \"def initialize_optimizer(model, args):\\n parameters = [p for p in model.parameters() if p.requires_grad]\\n if args.optimizer == 'sgd':\\n optimizer = optim.SGD(parameters, args.learning_rate,\\n momentum=args.momentum,\\n weight_decay=args.weight_decay)\\n elif args.optimizer == 'adam':\\n optimizer = optim.Adam(parameters, args.learning_rate,\\n weight_decay=args.weight_decay)\\n elif args.optimizer == 'adamax':\\n optimizer = optim.Adamax(parameters, args.learning_rate,\\n weight_decay=args.weight_decay)\\n elif args.optimizer == 'adagrad':\\n optimizer = optim.Adagrad(parameters, args.learning_rate,\\n weight_decay=args.weight_decay)\\n scheduler = ReduceLROnPlateau(optimizer, 'min', verbose=True)\\n return optimizer, scheduler\",\n \"def build_optimizer(cfg: CfgNode, model: torch.nn.Module) -> torch.optim.Optimizer:\\n norm_module_types = (\\n torch.nn.BatchNorm1d,\\n torch.nn.BatchNorm2d,\\n torch.nn.BatchNorm3d,\\n torch.nn.SyncBatchNorm,\\n # NaiveSyncBatchNorm inherits from BatchNorm2d\\n torch.nn.GroupNorm,\\n torch.nn.InstanceNorm1d,\\n torch.nn.InstanceNorm2d,\\n torch.nn.InstanceNorm3d,\\n torch.nn.LayerNorm,\\n torch.nn.LocalResponseNorm,\\n )\\n params: List[Dict[str, Any]] = []\\n memo: Set[torch.nn.parameter.Parameter] = set()\\n for module in model.modules():\\n for key, value in module.named_parameters(recurse=False):\\n if not value.requires_grad:\\n continue\\n # Avoid duplicating parameters\\n if value in memo:\\n continue\\n memo.add(value)\\n lr = cfg.SOLVER.BASE_LR\\n weight_decay = cfg.SOLVER.WEIGHT_DECAY\\n if isinstance(module, norm_module_types):\\n weight_decay = cfg.SOLVER.WEIGHT_DECAY_NORM\\n elif key == \\\"bias\\\":\\n # NOTE: unlike Detectron v1, we now default BIAS_LR_FACTOR to 1.0\\n # and WEIGHT_DECAY_BIAS to WEIGHT_DECAY so that bias optimizer\\n # hyperparameters are by default exactly the same as for regular\\n # weights.\\n lr = cfg.SOLVER.BASE_LR * cfg.SOLVER.BIAS_LR_FACTOR\\n weight_decay = cfg.SOLVER.WEIGHT_DECAY_BIAS\\n params += [{\\\"params\\\": [value], \\\"lr\\\": lr, \\\"weight_decay\\\": weight_decay}]\\n\\n optimizer = torch.optim.SGD(params, cfg.SOLVER.BASE_LR, momentum=cfg.SOLVER.MOMENTUM)\\n return optimizer\",\n \"def __init__(self, model, src_vocab, tgt_vocab):\\n self.max_length = 120\\n if torch.cuda.is_available():\\n self.model = model.cuda()\\n else:\\n self.model = model.cpu()\\n self.model.eval()\\n self.src_vocab = src_vocab\\n self.tgt_vocab = tgt_vocab\",\n \"def optimize(self, model):\\n model.optimize_params(\\n max_iters=self.max_iters, max_beta_iters=self.max_beta_iters,\\n max_U_iters=self.max_U_iters, rel_tol=self.rel_tol,\\n optimize_beta=self.optimize_beta, optimize_U=self.optimize_U,\\n compute_D=self.compute_D\\n )\\n return model\",\n \"def get_optimizer(model, lr, transfer_optim):\\n\\n # different otpimizer lr for transfer to reuse low level features\\n if transfer_optim:\\n if isinstance(model, UNetRegressionModel):\\n optimizer = torch.optim.Adam([{'params':\\n list(model.msd.inc.parameters()) +\\n list(model.msd.down1.parameters()) +\\n list(model.msd.down2.parameters()), 'lr': 1e-6},\\n {'params': \\n list(model.msd.down3.parameters()) +\\n list(model.msd.down4.parameters()) +\\n list(model.msd.up1.parameters()), 'lr': 1e-5},\\n {'params': \\n list(model.msd.up2.parameters()) + list(model.msd.up3.parameters()) +\\n list(model.msd.up4.parameters()) + list(model.msd.outc.parameters()), 'lr': 1e-4},\\n ])\\n\\n else:\\n params = list(model.msd.parameters())\\n # case: MSD_d30\\n if len(params) < 40:\\n optimizer = torch.optim.Adam([{'params': params[1:10], 'lr':1e-6},\\n {'params': params[:0]+ params[10:20], 'lr':1e-5},\\n {'params': params[20:], 'lr':1e-4},\\n ])\\n # case: MSD_d80\\n else:\\n optimizer = torch.optim.Adam([{'params': params[1:20], 'lr':1e-6},\\n {'params': params[:0]+ params[20:40], 'lr':1e-5},\\n {'params': params[40:], 'lr':1e-4},\\n ])\\n else:\\n optimizer = torch.optim.Adam(model.msd.parameters(), lr)\\n\\n return optimizer\",\n \"def __init__(self, model_class, model=None, env=None, exploration=None,\\n gamma=0.99, memory_size=100000, batch_size=64, target_update_frequency=1000, saving_dir=None):\\n self.model_class = model_class\\n self.env = env\\n self.exploration = exploration\\n self.device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n self.policy_net = None\\n self.target_net = None\\n self.optimizer = None\\n if model:\\n self.policy_net = model\\n self.target_net = copy.deepcopy(self.policy_net)\\n self.policy_net = self.policy_net.to(self.device)\\n self.target_net = self.target_net.to(self.device)\\n self.target_net.eval()\\n self.optimizer = optim.Adam(self.policy_net.parameters(), lr=0.0001)\\n self.memory = ReplayMemory(memory_size)\\n self.batch_size = batch_size\\n self.gamma = gamma\\n self.target_update = target_update_frequency\\n self.steps_done = 0\\n self.episodes_done = 0\\n self.episode_rewards = []\\n self.episode_lengths = []\\n self.saving_dir = saving_dir\\n\\n self.state = None\",\n \"def optimizerFactory(hybridModel, params):\\n\\n if params['optim']['name'] == 'adam':\\n return torch.optim.Adam(\\n hybridModel.parameters(),lr=params['optim']['lr'], \\n betas=(0.9, 0.999), eps=1e-08, \\n weight_decay=params['optim']['weight_decay'], amsgrad=False\\n )\\n elif params['optim']['name'] == 'sgd': \\n return torch.optim.SGD(\\n hybridModel.parameters(), lr=params['optim']['lr'], \\n momentum=params['optim']['momentum'], weight_decay=params['optim']['weight_decay']\\n )\\n \\n else:\\n raise NotImplemented(f\\\"Optimizer {params['optim']['name']} not implemented\\\")\",\n \"def add_optimizer(self, optimizer):\\n assert isinstance(optimizer, torch.optim.Optimizer)\\n setattr(self, 'optimizer', optimizer)\",\n \"def fetch_optimizer(args, model):\\n optimizer = optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.wdecay, eps=args.epsilon)\\n\\n scheduler = optim.lr_scheduler.OneCycleLR(optimizer, args.lr, args.num_steps + 100,\\n pct_start=0.05, cycle_momentum=False, anneal_strategy='linear')\\n\\n return optimizer, scheduler\",\n \"def _create_model(self):\\n if torch.cuda.is_available():\\n model = torch.jit.load(self.torch_jit).cuda()\\n else:\\n model = torch.jit.load(self.torch_jit)\\n model.eval()\\n return model\",\n \"def __init__(self, model: torch.nn.Module) -> None:\\n self.model = copy.deepcopy(model)\\n self.model.eval().to(device=DEVICE)\\n self.rule_layer_map: List[Tuple[List[str], rules.LrpRule,\\n Dict[str, Union[torch.Tensor, float]]]] = []\\n self.input_nchw: Optional[torch.Tensor] = None\\n self.label_idx_n: Optional[torch.Tensor] = None\\n self.relevance_scores_nchw: Optional[torch.Tensor] = None\\n self.explained_class_indices: Optional[torch.Tensor] = None\",\n \"def create_optimizer(self, context, optimizer, host):\\n pass\",\n \"def create_optimizer(parameters, optimizer_class, optim_params, model_name='model'):\\n opt = optimizer_class(parameters, **optim_params)\\n if special_parameters.load_model:\\n _load_optimizer(opt, model_name)\\n return opt\",\n \"def define_model_and_optimizer(self):\\r\\n print(\\\"* Defining model and optimizer.\\\", flush=True)\\r\\n job_dir = self.C.job_dir\\r\\n\\r\\n if self.C.restart:\\r\\n print(\\\"-- Loading model from previous saved state.\\\", flush=True)\\r\\n self.restart_epoch = util.get_restart_epoch()\\r\\n self.model = torch.load(f\\\"{job_dir}model_restart_{self.restart_epoch}.pth\\\")\\r\\n\\r\\n print(\\r\\n f\\\"-- Backing up as \\\"\\r\\n f\\\"{job_dir}model_restart_{self.restart_epoch}_restarted.pth.\\\",\\r\\n flush=True,\\r\\n )\\r\\n shutil.copyfile(\\r\\n f\\\"{job_dir}model_restart_{self.restart_epoch}.pth\\\",\\r\\n f\\\"{job_dir}model_restart_{self.restart_epoch}_restarted.pth\\\",\\r\\n )\\r\\n\\r\\n else:\\r\\n print(\\\"-- Initializing model from scratch.\\\", flush=True)\\r\\n self.model = models.initialize_model()\\r\\n\\r\\n self.restart_epoch = 0\\r\\n\\r\\n start_epoch = self.restart_epoch + 1\\r\\n end_epoch = start_epoch + self.C.epochs\\r\\n\\r\\n print(\\\"-- Defining optimizer.\\\", flush=True)\\r\\n self.optimizer = torch.optim.Adam(\\r\\n params=self.model.parameters(),\\r\\n lr=self.C.init_lr,\\r\\n weight_decay=self.C.weight_decay,\\r\\n )\\r\\n\\r\\n return start_epoch, end_epoch\",\n \"def _build_model(self, model):\\n model = model(self.state_dim, n_actions=self.n_actions)\\n model.compile(loss=self._huber_loss,\\n optimizer=optimizers.Adam(lr=self.learning_rate))\\n return model\",\n \"def __init__(self, model_name='vgg16'):\\n trainer = Trainer(model_name=model_name)\\n self.model = trainer.model\\n self.model_save_dir = trainer.model_save_dir\\n self.model_name = model_name\",\n \"def get_adv_optimizer(self, mode: str) -> torch.optim.Optimizer:\\n pass\",\n \"def get_optimizer(cfg, model_parameters):\\r\\n op_params = cfg.copy()\\r\\n del op_params['name']\\r\\n\\r\\n optimizer = {\\r\\n 'sgd': torch.optim.SGD,\\r\\n 'adam': torch.optim.Adam\\r\\n }[cfg.name]\\r\\n return optimizer(model_parameters, **op_params)\",\n \"def create_engine(model, optimizer, loss, device):\\n model.to(device)\\n\\n def _update(engine, batch):\\n data, label = batch\\n num_channels = 1 if len(data.shape) == 2 else data.shape[1]\\n data = data.view(-1, 1, data.shape[-1])\\n data = data.to(device)\\n label = label.to(device)\\n label = label.float()\\n\\n model.train()\\n model.zero_grad()\\n optimizer.zero_grad()\\n\\n output = model(data)\\n output = output.view(-1, num_channels, output.shape[-1])\\n _loss = loss(output, label)\\n _loss.backward()\\n optimizer.step()\\n\\n return _loss.item()\\n\\n return Engine(_update)\",\n \"def run_onnx_optimizer(onnx_model):\\n try:\\n onnx_polish_model = onnx.utils.polish_model\\n except AttributeError:\\n pass\\n else:\\n return onnx_polish_model(onnx_model)\\n\\n try:\\n # pylint: disable=import-outside-toplevel\\n import onnxoptimizer\\n except ImportError:\\n pass\\n else:\\n return onnxoptimizer.optimize(onnx_model)\\n\\n return onnx_model\",\n \"def __init__(self,\\n model: Type[torch.nn.Module],\\n optimizer: Type[optim.PyroOptim] = None,\\n loss: Type[infer.ELBO] = None,\\n enumerate_parallel: bool = False,\\n seed: int = 1,\\n **kwargs: Union[str, float]\\n ) -> None:\\n pyro.clear_param_store()\\n set_deterministic_mode(seed)\\n self.device = kwargs.get(\\n \\\"device\\\", 'cuda' if torch.cuda.is_available() else 'cpu')\\n if optimizer is None:\\n lr = kwargs.get(\\\"lr\\\", 1e-3)\\n optimizer = optim.Adam({\\\"lr\\\": lr})\\n if loss is None:\\n if enumerate_parallel:\\n loss = infer.TraceEnum_ELBO(\\n max_plate_nesting=1, strict_enumeration_warning=False)\\n else:\\n loss = infer.Trace_ELBO()\\n guide = model.guide\\n if enumerate_parallel:\\n guide = infer.config_enumerate(guide, \\\"parallel\\\", expand=True) \\n self.svi = infer.SVI(model.model, guide, optimizer, loss=loss)\\n self.loss_history = {\\\"training_loss\\\": [], \\\"test_loss\\\": []}\\n self.current_epoch = 0\",\n \"def __init__(self, model: Module, settings: PGActorSettings) -> None:\\n super().__init__(settings)\\n\\n final_layer, self.network = finalize_module(model, from_numpy(self.state_space.sample()),\\n self._num_policy_params)\\n self.settings.optimizer.add_param_group({\\\"params\\\": final_layer.parameters()})\",\n \"def __init__(self, name, model, log_dir, lr, lr_decay_step, adam=False):\\n\\t\\tsuper(Trainer, self).__init__(self.update_model)\\n\\t\\tself.model = model\\n\\t\\t# tqdm\\n\\t\\tProgressBar(persist=True).attach(self)\\n\\t\\t# Optimizer\\n\\t\\tparams = [p for p in model.parameters() if p.requires_grad]\\n\\t\\tif adam:\\n\\t\\t\\tself.optimizer = torch.optim.Adam(params, lr=lr)\\n\\t\\telse:\\n\\t\\t\\tself.optimizer = torch.optim.SGD(params, lr=lr, momentum=0.9)\\n\\t\\t# Scheduler\\n\\t\\tif lr_decay_step > 0:\\n\\t\\t\\tself.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=lr_decay_step, gamma=0.1)\\n\\t\\t\\tself.add_event_handler(Events.EPOCH_COMPLETED, lambda e: e.scheduler.step())\\n\\t\\telse:\\n\\t\\t\\tself.scheduler = None\\n\\t\\t# Terminate if nan values found\\n\\t\\tself.add_event_handler(Events.ITERATION_COMPLETED, TerminateOnNan())\\n\\t\\t# Tensorboard logging\\n\\t\\tself.tb_logger = TensorboardLogger(log_dir=os.path.join(log_dir, name))\\n\\t\\tself.add_event_handler(Events.COMPLETED, lambda x: self.tb_logger.close())\\n\\t\\tself.tb_logger.attach(self,\\n\\t\\t log_handler=OptimizerParamsHandler(self.optimizer),\\n\\t\\t event_name=Events.EPOCH_COMPLETED)\\n\\t\\tself.tb_logger.attach(self,\\n\\t\\t log_handler=OutputHandler(tag='training', output_transform=lambda x: {\\n\\t\\t\\t 'rpn_box_loss': round(self.state.output['loss_rpn_box_reg'].item(), 4),\\n\\t\\t\\t 'rpn_cls_loss': round(self.state.output['loss_objectness'].item(), 4),\\n\\t\\t\\t 'roi_box_loss': round(self.state.output['loss_box_reg'].item(), 4),\\n\\t\\t\\t 'roi_cls_loss': round(self.state.output['loss_classifier'].item(), 4)\\n\\t\\t }),\\n\\t\\t event_name=Events.EPOCH_COMPLETED)\\n\\t\\t# Run on GPU (cuda) if available\\n\\t\\tif torch.cuda.is_available():\\n\\t\\t\\ttorch.cuda.set_device(int(get_free_gpu()))\\n\\t\\t\\tmodel.cuda(torch.cuda.current_device())\",\n \"def __init__(self, model: Callable, q: Callable, loss: Callable,\\n optimizer: jax_optim.Optimizer, initial_params: Dict):\\n self.model = model\\n self.q = q\\n self.loss = loss\\n self.optimizer = optimizer\\n self.optimizer_state = self.optimizer.init_fn(initial_params)\\n self.step = 0\",\n \"def add_optimizer(self, optimizer):\\n assert isinstance(optimizer, torch.optim.Optimizer)\\n setattr(self, 'optimizer'+str(self._optimizer_counter), optimizer)\\n self._optimizer_counter += 1\\n # optimizer indexing : optimizer 0 is the optimizer for layer 0\",\n \"def _create_optimizer(self):\\n\\n with tf.name_scope(\\\"optimizer\\\"):\\n self.train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.loss)\",\n \"def init_optimizer(network, config):\\n # define optimizer and loss\\n if config.optimizer == 'adadelta':\\n opt = torch.optim.Adadelta(network.parameters(), lr=config.lr, weight_decay=config.weight_decay)\\n elif config.optimizer == 'adam':\\n opt = torch.optim.Adam(network.parameters(), lr=config.lr, weight_decay=config.weight_decay)\\n elif config.optimizer == 'rmsprop':\\n opt = torch.optim.RMSprop(network.parameters(), lr=config.lr, weight_decay=config.weight_decay)\\n return opt\",\n \"def make_optimizer(self):\\r\\n # parameters = [self.encoder.parameters(), self.decoder.parameters(), self.spec_enc.parameters()]\\r\\n if self.flags.optim == 'Adam':\\r\\n op = torch.optim.Adam(self.model.parameters(), lr=self.flags.lr, weight_decay=self.flags.reg_scale)\\r\\n elif self.flags.optim == 'RMSprop':\\r\\n op = torch.optim.RMSprop(self.model.parameters(), lr=self.flags.lr, weight_decay=self.flags.reg_scale)\\r\\n elif self.flags.optim == 'SGD':\\r\\n op = torch.optim.SGD(self.model.parameters(), lr=self.flags.lr, weight_decay=self.flags.reg_scale)\\r\\n else:\\r\\n raise Exception(\\\"Your Optimizer is neither Adam, RMSprop or SGD, please change in param or contact Ben\\\")\\r\\n return op\",\n \"def build_model(self):\\n self.global_step = tf.Variable(0, name=\\\"global_step\\\", trainable=False)\\n\\n if self.config.optimizer == 'sgd':\\n self.optimizer = tf.keras.optimizers.SGD(learning_rate=self.config.learning_rate)\\n elif self.config.optimizer == 'rms':\\n self.optimizer = tf.keras.optimizers.RMSprop(learning_rate=self.config.learning_rate)\\n elif self.config.optimizer == 'adam':\\n self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate)\\n elif self.config.optimizer == 'adagrad':\\n self.optimizer = tf.keras.optimizers.Adagrad(learning_rate=self.config.learning_rate)\\n elif self.config.optimizer == 'adadelta':\\n self.optimizer = tf.keras.optimizers.Adadelta(learning_rate=self.config.learning_rate)\\n else:\\n raise NotImplementedError(\\\"No support for %s optimizer\\\" % self.config.optimizer)\\n \\n if self.config.optimizer in ['rms', 'adagrad', 'adadelta']:\\n with tf.device('cpu:0'):\\n self.model.def_parameters()\\n else:\\n self.model.def_parameters()\\n\\n self.config.summary()\\n self.config.summary_hyperparameter(self.model.model_name)\",\n \"def compile_optimizer(self):\\n optimizer = torch.optim.Adam(self.parameters(), lr=self.cfg.learning_rate)\\n\\n return optimizer\",\n \"def _inst_optimizer(self):\\n optimizer = Optimizers(self.m_cfg['configs']['lr_politics']['optimizer']).value\\n lr_schedule = self.m_cfg['configs']['lr_politics']['lr']\\n opt = optimizer(learning_rate=lr_schedule)\\n return opt\",\n \"def create_optimizer(net, optimizer_state_dict, learning_rate, device='cuda'):\\n # define optimizer\\n optimizer = optim.Adam([{\\n 'params': net.net.parameters(),\\n 'initial_lr': learning_rate\\n }])\\n # load optimizer checkpoint if available\\n if optimizer_state_dict is not None:\\n target_device = 'cpu' if device == 'cpu' else 'cuda'\\n # load the optimizer weights\\n optimizer.load_state_dict(optimizer_state_dict)\\n for state in optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = getattr(v, target_device)()\\n return optimizer\",\n \"def init_optimizer_for_pruning(cls, optimizer):\\n assert (cls.__optimizer is None), \\\"ASP has initialized optimizer already.\\\"\\n assert (cls.__calculate_mask is not None), \\\"Called ASP.init_optimizer_for_pruning before ASP.init_model_for_pruning.\\\"\\n\\n # store pointer to original optimizer step method\\n cls.__optimizer = optimizer\\n cls.__optimizer.__step = optimizer.step\\n\\n def __step(opt_self, *args, **kwargs):\\n # prune gradients before step method\\n with torch.no_grad():\\n for module_name, module, p_name, p, mask, pruned in cls.__sparse_parameters:\\n p.grad.mul_(mask)\\n # call original optimizer step method\\n rval = opt_self.__step(*args, **kwargs)\\n # prune parameters after step method\\n with torch.no_grad():\\n for module_name, module, p_name, p, mask, pruned in cls.__sparse_parameters:\\n p.mul_(mask)\\n return rval\\n cls.__optimizer.step = types.MethodType(__step, cls.__optimizer)\",\n \"def get_optimizer(self, optimizer, params):\\n # Reference: https://pytorch.org/docs/stable/optim.html#per-parameter-options\\n optimizer = getattr(optim, optimizer, \\\"Adam\\\")(\\n [\\n {'params': self.shared_conv.parameters()},\\n {'params': self.detector.parameters()},\\n # {'params': self.recognizer.parameters()},\\n ],\\n **params\\n )\\n\\n return optimizer\",\n \"def _get_optim(\\n self,\\n model: nn.Module,\\n optim_class: Type[torch.optim.Optimizer],\\n multi_tensor: bool,\\n ) -> torch.optim.Optimizer:\\n param_groups = self._get_param_groups(model)\\n return optim_class(param_groups, lr=5e-3, foreach=multi_tensor)\",\n \"def __init__(self, model: Editable, loss_function, error_function=classification_error, opt=None,\\n stability_coeff=0.01, editability_coeff=0.01, max_norm=None, **kwargs):\\n opt = opt if opt is not None else torch.optim.Adam(model.parameters())\\n super().__init__(model, loss_function=loss_function, opt=opt, error_function=error_function, **kwargs)\\n self.stability_coeff, self.editability_coeff, self.max_norm = stability_coeff, editability_coeff, max_norm\",\n \"def __init__(self, *, model, criterion, optimizer, dataloader, logdir='.', storage='storage.hdf5',\\n transformation=lambda x: x, loss_decay=0.95, split_sample=None):\\n\\n self.model = model\\n self.criterion = criterion\\n self.optimizer = optimizer\\n self.dataloader = dataloader\\n self.logdir = logdir\\n self.storage = os.path.join(logdir, storage) if storage is not None else None\\n self.transformation = transformation\\n self.cuda = bool(next(model.parameters()).is_cuda)\\n self.dtype = next(model.parameters()).dtype\\n self.loss_decay = loss_decay\\n self.epochs = 0\\n self.steps = 0\\n self.split_sample = split_sample if callable(split_sample) else self._split_sample\\n\\n # register base handlers\\n self.events = {event: [] for event in events.event_list}\\n self.register_event_handler(events.AFTER_TRAINING, self.save, directory=self.logdir)\\n self.register_event_handler(events.AFTER_TRAINING, self.close_storage)\\n self.register_event_handler(events.EACH_STEP, TrainingLoss(), monitor=(storage is not None))\\n\\n super().__init__()\\n\\n # unify backward call for all types of optimizer\\n if not hasattr(self.optimizer, 'backward'):\\n setattr(self.optimizer, 'backward', self._backward)\",\n \"def __init__(self, state_dim, action_dim, learning_rate, weight_decay):\\n self.dynamics_net = ForwardModel(state_dim, action_dim)\\n self.rewards_net = RewardModel(state_dim, action_dim)\\n self.done_net = RewardModel(state_dim, action_dim)\\n\\n self.dyn_optimizer = tfa_optimizers.AdamW(\\n learning_rate=learning_rate, weight_decay=weight_decay)\\n self.reward_optimizer = tfa_optimizers.AdamW(\\n learning_rate=learning_rate, weight_decay=weight_decay)\\n self.done_optimizer = tfa_optimizers.AdamW(\\n learning_rate=learning_rate, weight_decay=weight_decay)\",\n \"def inject(self, model):\\n if not hasattr(model, 'train_function'):\\n raise RuntimeError('You must compile your model before using it.')\\n\\n model._check_trainable_weights_consistency()\\n\\n if model.train_function is None:\\n inputs = (model._feed_inputs +\\n model._feed_targets +\\n model._feed_sample_weights)\\n if model._uses_dynamic_learning_phase():\\n inputs += [K.learning_phase()]\\n fast_params = model._collected_trainable_weights\\n\\n with K.name_scope('training'):\\n with K.name_scope(model.optimizer.__class__.__name__):\\n training_updates = model.optimizer.get_updates(\\n params=fast_params,\\n loss=model.total_loss)\\n slow_params = [K.variable(p) for p in fast_params]\\n fast_updates = (model.updates +\\n training_updates +\\n model.metrics_updates)\\n\\n slow_updates, copy_updates = [], []\\n for p, q in zip(fast_params, slow_params):\\n slow_updates.append(K.update(q, q + self.alpha * (p - q)))\\n copy_updates.append(K.update(p, q))\\n\\n # Gets loss and metrics. Updates weights at each call.\\n fast_train_function = K.function(\\n inputs,\\n [model.total_loss] + model.metrics_tensors,\\n updates=fast_updates,\\n name='fast_train_function',\\n **model._function_kwargs)\\n\\n def F(inputs):\\n self.count += 1\\n R = fast_train_function(inputs)\\n if self.count % self.k == 0:\\n K.batch_get_value(slow_updates)\\n K.batch_get_value(copy_updates)\\n return R\\n\\n #### REM : C'est pas super propre ca comme manière de faire\\n #### Tu rompts l'encapsulation de la classe \\n model.train_function = F\",\n \"def get_unet_model(self):\\n # create optimizer instance\\n config = {\\n 'class_name': self.optimizer,\\n 'config': self.optimizer_params}\\n optimizer = get_optimizer(config)\\n\\n self.model = unet(optimizer=optimizer,\\n loss=self.loss,\\n metrics=self.metrics,\\n input_size=self.input_size,\\n pretrained_weights=self.pretrained_weights)\",\n \"def set_lr(model: Union[tf.keras.Model, torch.nn.Module], lr: float, weight_decay: Optional[float] = None):\\n assert hasattr(model, \\\"fe_compiled\\\") and model.fe_compiled, \\\"set_lr only accept models from fe.build\\\"\\n if isinstance(model, tf.keras.Model):\\n # when using decoupled weight decay like SGDW or AdamW, weight decay factor needs to change together with lr\\n # see https://www.tensorflow.org/addons/api_docs/python/tfa/optimizers/DecoupledWeightDecayExtension for detail\\n if isinstance(model.current_optimizer, tfa.optimizers.DecoupledWeightDecayExtension) or hasattr(\\n model.current_optimizer, \\\"inner_optimizer\\\") and isinstance(\\n model.current_optimizer.inner_optimizer, tfa.optimizers.DecoupledWeightDecayExtension):\\n if weight_decay is None:\\n weight_decay = tf.keras.backend.get_value(model.current_optimizer.weight_decay) * lr / get_lr(model)\\n tf.keras.backend.set_value(model.current_optimizer.weight_decay, weight_decay)\\n tf.keras.backend.set_value(model.current_optimizer.lr, lr)\\n elif isinstance(model, torch.nn.Module):\\n for param_group in model.current_optimizer.param_groups:\\n param_group['lr'] = lr\\n else:\\n raise ValueError(\\\"Unrecognized model instance {}\\\".format(type(model)))\",\n \"def setup_optims(self):\\n lr = self.train_config['lr']\\n b1 = self.train_config['b1']\\n b2 = self.train_config['b2']\\n weight_decay = self.train_config['weight_decay']\\n self.opt = torch.optim.Adam(self.network.parameters(), lr=lr, betas=(b1, b2),\\n weight_decay=weight_decay)\",\n \"def __init__(self,\\n model=None,\\n train_dataset=None,\\n eval_dataset=None,\\n optimizer=None,\\n criterion=None,\\n cpu: bool = False):\\n\\n # import torch for initialization\\n torch = import_optional_dependency(\\\"torch\\\")\\n\\n # ============== basic parameters ============== #\\n # the device that used to train models, which can automatically set\\n self.device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() and not cpu else \\\"cpu\\\")\\n # the optimizer of training\\n self.optimizer = optimizer\\n # the neural network model\\n self.model = model.to(self.device) if model else None\\n # the criterion of training\\n self.criterion = criterion.to(self.device) if criterion else None\\n # the dataset for training\\n self.train_dataset = train_dataset\\n # the dataset for evaluation\\n self.eval_dataset = eval_dataset\\n # the training process would show information if self.info is True\\n self.info = True\\n\\n # ============== the parameters of training ============== #\\n # the loss average meter for every epoch\\n self.epoch_loss = AverageMeter()\\n # the counter for training\\n self.epoch = 0\\n # training process for iteration\\n self.batch_process = None\",\n \"def __init__(self, conf):\\n self.model_conf = conf[\\\"model\\\"]\\n self.epochs = self.model_conf.getint(\\\"n_epochs\\\")\\n self.epoch = self.model_conf.getint(\\\"epoch_start\\\")\\n self.batch_size = self.model_conf.getint(\\\"batch_size\\\")\\n self.criterion = nn.CrossEntropyLoss()\\n self.device = torch.device(self.model_conf.get('device'))\\n #self.model = (\\n # eval(self.model_conf.get('name'))(self.model_conf).to(self.device)\\n #)\\n self.model = nn.DataParallel(\\n eval(self.model_conf.get('name'))(self.model_conf).to(self.device)\\n )\\n total_params = sum(p.numel() for p in self.model.parameters())\\n print(\\\"Created model {}: {} parameters\\\"\\n .format(self.model_conf.get('name'), total_params))\\n if self.model_conf.get(\\\"optim\\\") == 'SGD':\\n self.optimizer = optim.SGD(\\n self.model.parameters(),\\n lr=self.model_conf.getfloat(\\\"learning_rate\\\"),\\n momentum=self.model_conf.getfloat(\\\"momentum\\\"),\\n weight_decay=self.model_conf.getfloat(\\\"weight_decay\\\"))\\n elif self.model_conf.get(\\\"optim\\\") == 'Adam':\\n self.optimizer = optim.Adam(\\n self.model.parameters(),\\n lr=self.model_conf.getfloat(\\\"learning_rate\\\"),\\n betas=json.loads(self.model_conf.get(\\\"betas\\\")))\\n else:\\n raise ValueError('Only SGD is supported')\\n\\n if self.model_conf.get(\\\"checkpoint\\\") is not None:\\n self.load_checkpoint(self.model_conf.get(\\\"checkpoint\\\"))\\n\\n self.checkpoints_path = conf.get(\\\"paths\\\", \\\"checkpoints\\\")\\n self.results_path = conf.get(\\\"paths\\\", \\\"results\\\")\\n self.best_accuracy = 0\\n self.train_size = None\\n self.valid_size = None\\n self.iteration_print_freq = conf.getint(\\\"log\\\", \\\"iteration_print_freq\\\")\",\n \"def convert_to_torch_amp(model: nn.Module,\\n optimizer: Optimizer,\\n criterion: Optional[_Loss] = None,\\n amp_config: Optional[Config] = None):\\n model = TorchAMPModel(model)\\n if amp_config is None:\\n amp_config = dict()\\n optimizer = TorchAMPOptimizer(optimizer, **amp_config)\\n if criterion:\\n criterion = TorchAMPLoss(criterion)\\n return model, optimizer, criterion\",\n \"def __init__(self):\\n \\n self.model = Net()\\n\\n if torch.cuda.is_available():\\n map_location=torch.device('cuda')\\n else:\\n map_location=torch.device('cpu')\\n\\n # load parameters\\n self.model.load_state_dict(torch.load('model.pt',\\n map_location=map_location)) \\n \\n if torch.cuda.is_available():\\n self.model.cuda()\\n else:\\n self.model.cpu()\\n \\n self.model.eval()\",\n \"def __init__(\\n self,\\n model: nn.Module,\\n branch_losses: Dict[str, int],\\n branch_loss_params: Dict[str, Dict[str, Any]] = None,\\n branch_metrics: Dict[str, List[str]] = None,\\n optimizer: str = \\\"adam\\\",\\n lookahead: bool = False,\\n optim_params: Dict[str, Dict[str, Any]] = None,\\n scheduler: str = \\\"reduce_on_plateau\\\",\\n scheduler_params: Dict[str, Any] = None,\\n log_freq: int = 100,\\n **kwargs,\\n ) -> None:\\n super().__init__()\\n self.model = model\\n self.heads = model.heads\\n self.aux_key = model.aux_key\\n self.inst_key = model.inst_key\\n\\n self.optimizer = optimizer\\n self.optim_params = optim_params\\n self.scheduler = scheduler\\n self.scheduler_params = scheduler_params\\n self.lookahead = lookahead\\n\\n self.branch_losses = branch_losses\\n self.branch_metrics = branch_metrics\\n self.branch_loss_params = branch_loss_params\\n self.log_freq = log_freq\\n\\n self._validate_branch_args()\\n self.save_hyperparameters(ignore=\\\"model\\\")\\n\\n self.criterion = self.configure_loss()\\n metrics = self.configure_metrics()\\n self.train_metrics = deepcopy(metrics)\\n self.val_metrics = deepcopy(metrics)\\n self.test_metrics = deepcopy(metrics)\",\n \"def load_model(model_path: str) -> object:\\n model = torch.load(model_path)\\n model.eval()\\n return model\",\n \"def _make_model(self):\\n self._model = tf.estimator.Estimator(model_fn=self.model_fn,\\n model_dir=self.model_dir,\\n config=self._config,\\n params=self._params,\\n )\",\n \"def optimizer_setup(optimizer_class: Type[torch.optim.Optimizer], **hyperparameters) -> \\\\\\n Callable[[torch.nn.Module], torch.optim.Optimizer]:\\n\\n def f(model):\\n return optimizer_class(model.parameters(), **hyperparameters)\\n\\n return f\",\n \"def setup_trainer(model, train_dir, train_loader, val_loader,\\n property_map, exclude=[]):\\n hooks = build_hooks(train_dir=train_dir, property_map=property_map)\\n\\n trainable_params = filter(lambda p: p.requires_grad, model.parameters())\\n trainable_params = filter(lambda p: p not in exclude, trainable_params)\\n\\n optim = build_optimizer(trainable_params=trainable_params)\\n loss_fn = build_loss(property_map=property_map)\\n trainer = Trainer(train_dir, model, loss_fn, optim, train_loader,\\n val_loader, hooks=hooks)\\n return trainer\",\n \"def model_creator(config):\\n return nn.Linear(1, 1)\",\n \"def setup_optimizer(params, config):\\n if config.METHOD == 'AdaMod':\\n return AdaMod(params,\\n lr=config.LR,\\n betas=(config.BETA, 0.999),\\n beta3=config.BETA3,\\n weight_decay=config.WD)\\n elif config.METHOD == 'Adam':\\n return torch.optim.Adam(params,\\n lr=config.LR,\\n betas=(config.BETA, 0.999),\\n weight_decay=config.WD)\\n elif config.METHOD == 'SGD':\\n return torch.optim.SGD(params,\\n lr=config.LR,\\n momentum=config.MOMENTUM,\\n dampening=config.DAMPENING,\\n weight_decay=config.WD,\\n nesterov=config.NESTEROV)\\n else:\\n raise NotImplementedError\",\n \"def get_optimizer(model, learning_rate, name=\\\"SGD\\\"):\\n \\n optimizer_dict = {\\\"SGD\\\": optim.SGD(model.parameters(), lr=learning_rate,\\n weight_decay=0.0001, momentum=0.9),\\n \\\"Adam\\\": optim.Adam(model.parameters(), lr=learning_rate,\\n weight_decay=0.0001),\\n \\\"RMSProp\\\": optim.RMSprop(model.parameters(), lr=learning_rate,\\n weight_decay=0.0001)}\\n return optimizer_dict[name]\",\n \"def __init__(self,\\n verbosity=1,\\n model=None,\\n path=None,\\n prefix=None,\\n **kwargs):\\n if K.BACKEND == 'tensorflow' and tf is not None:\\n min_version = tf.__version__.split(\\\".\\\")[1]\\n maj_version = tf.__version__.split(\\\".\\\")[0]\\n if maj_version in [\\\"2\\\"] and min_version in [\\\"3\\\", \\\"4\\\"]:\\n raise NotImplementedError(f\\\"\\\"\\\"\\n Not implemented due to a bug in tensorflow as shown here https://github.com/tensorflow/tensorflow/issues/44646\\n You can use functional API instead by using\\n from ai4water.functional import Model\\n instead of \\n from ai4water import Model\\n Or change the tensorflow version. Current version is {tf.__version__}. \\n \\\"\\\"\\\")\\n\\n tf_kwargs = {}\\n for arg in ['inputs', 'outputs']:\\n if arg in kwargs:\\n tf_kwargs[arg] = kwargs[arg]\\n\\n self._go_up = False\\n\\n MODEL.__init__(self, **tf_kwargs)\\n\\n self._go_up = True\\n BaseModel.__init__(self,\\n prefix=prefix,\\n path=path,\\n verbosity=verbosity,\\n model=model,\\n **kwargs)\\n\\n self.config['backend'] = K.BACKEND\\n\\n if torch is not None:\\n from .models._torch import Learner\\n self.torch_learner = Learner(\\n model=self,\\n batch_size=self.config['batch_size'],\\n num_epochs=self.config['epochs'],\\n shuffle=self.config['shuffle'],\\n to_monitor=self.config['monitor'],\\n patience=self.config['patience'],\\n path=self.path,\\n use_cuda=False,\\n wandb_config=self.config['wandb_config'],\\n verbosity=self.verbosity\\n )\\n\\n if self.category == \\\"DL\\\":\\n self.initialize_layers(self.config['model']['layers'])\\n\\n if K.BACKEND == 'tensorflow':\\n outs = self.call(self._input_lyrs(), run_call=False)\\n setattr(self, 'output_lyrs', outs)\\n self._go_up = False # do not reinitiate BaseModel and other upper classes\\n\\n maj_ver = int(tf.__version__.split('.')[0])\\n min_ver = int(tf.__version__.split('.')[1][0])\\n # in tf versions >= 2.5, we don't need to specify inputs and outputs as keyword arguments\\n if maj_ver>1 and min_ver>=5:\\n MODEL.__init__(self, self._input_lyrs(), self.output_lyrs)\\n else:\\n MODEL.__init__(self, inputs=self._input_lyrs(), outputs=self.output_lyrs)\\n\\n self.build(self._get_dummy_input_shape()) # will initialize ML models or build NNs\",\n \"def train(model, optimizer: torch.optim, data: torch_geometric.data.Data):\\n model.train()\\n optimizer.zero_grad()\\n F.nll_loss(model()[data.train_mask], data.y[data.train_mask]).backward()\\n optimizer.step()\\n\\n model.eval()\",\n \"def __init__(self, model):\\n self.output_weights = model.get_layer(\\\"output\\\").get_weights()[0]\\n self.cam_model = Model(inputs=model.input, outputs=(model.get_layer(\\\"activation\\\").output, model.get_layer(\\\"output\\\").output))\",\n \"def __init__(self,\\n forward_models,\\n forward_model_optim=tf.keras.optimizers.Adam,\\n forward_model_lr=0.001):\\n\\n super().__init__()\\n self.forward_models = forward_models\\n self.bootstraps = len(forward_models)\\n\\n # create optimizers for each model in the ensemble\\n self.forward_model_optims = [\\n forward_model_optim(learning_rate=forward_model_lr)\\n for i in range(self.bootstraps)]\",\n \"def create_custom_supervised_trainer(model, optimizer, loss_fn, metrics={}, device=None, prepare_batch=None):\\n\\n def _update(engine, batch):\\n model.train()\\n optimizer.zero_grad()\\n if not prepare_batch:\\n x, y = _prepare_batch(batch, device=device)\\n else:\\n x, y = prepare_batch(batch, device=device)\\n y_pred = model(x)\\n loss = loss_fn(y_pred, y)\\n loss.backward()\\n optimizer.step()\\n return loss.item(), y_pred, y\\n\\n def _metrics_transform(output):\\n return output[1], output[2]\\n\\n engine = Engine(_update)\\n\\n for name, metric in metrics.items():\\n metric._output_transform = _metrics_transform\\n metric.attach(engine, name)\\n\\n return engine\",\n \"def model_compile(self, model, optimiser, loss, metrics, learning_rate = None):\\n\\n if optimiser == \\\"sgd\\\":\\n model.compile(optimizer = SGD(lr = learning_rate),\\n loss = loss, metrics = metrics)\\n elif optimiser == \\\"rmsprop\\\":\\n model.compile(optimizer = RMSprop(lr = learning_rate),\\n loss = loss, metrics = metrics)\\n else:\\n model.compile(optimizer = optimiser, loss = loss,\\n metrics = metrics)\",\n \"def get_optimizer(model, lr_method, lr_rate):\\n lr_method_name = lr_method\\n\\n # initialize optimizer function\\n if lr_method_name == 'sgd':\\n optimizer = optim.SGD(model.parameters(), lr=lr_rate, momentum=0.9)\\n # scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)\\n elif lr_method_name == 'adagrad':\\n optimizer = optim.Adagrad(model.parameters(), lr=lr_rate)\\n # scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)\\n elif lr_method_name == 'adam':\\n optimizer = optim.Adam(model.parameters(), lr=lr_rate)\\n # scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.001)\\n else:\\n raise Exception('unknown optimization method.')\\n\\n return optimizer # , scheduler\",\n \"def _set_optimizer(self):\\n\\n if self.optimizer_name == 'Adam':\\n self.optimizer = optim.Adam(self.net.parameters(),\\n lr=self.learning_rate,\\n betas=self.betas,\\n eps=1e-8,\\n weight_decay=self.weight_decay)\\n elif self.optimizer_name == 'SGD':\\n self.optimizer = optim.SGD(self.net.parameters(),\\n lr=self.learning_rate,\\n momentum=self.momentum,\\n weight_decay=self.weight_decay)\\n elif self.optimizer_name == 'SGD_Nesterov':\\n self.optimizer = optim.SGD(self.net.parameters(),\\n lr=self.learning_rate,\\n momentum=self.momentum,\\n weight_decay=self.weight_decay,\\n nesterov=True)\\n elif self.optimizer_name == 'RMSprop':\\n self.optimizer = optim.Adagrad(self.net.parameters(),\\n lr=self.learning_rate,\\n momentum=self.momentum,\\n weight_decay=self.weight_decay)\\n elif self.optimizer_name == 'Adagrad':\\n self.optimizer = optim.Adagrad(self.net.parameters(),\\n lr=self.learning_rate,\\n weight_decay=self.weight_decay)\\n else:\\n print(\\\"Optimizer '\\\" + self.optimizer_name + \\\"' not implemented.\\\")\",\n \"def __init__(self, model_path: str = None):\\n\\n self.img_size = 128\\n self.tranform = transforms.Compose(\\n [transforms.Resize((self.img_size, self.img_size)), transforms.ToTensor()]\\n )\\n if model_path:\\n self.__load_model(path=model_path)\\n else:\\n print(\\\"Provide a path to trained model!\\\")\",\n \"def add_optimizer(self):\\n \\n with tf.variable_scope(\\\"optimizer\\\"):\\n\\n # Define optimizer and minimize loss\\n if self.OPTIM == \\\"RMSProp\\\":\\n self.optimizer = tf.train.RMSPropOptimizer(self.LEARN_RATE).\\\\\\n minimize(self.cost)\\n \\n elif self.OPTIM == \\\"GD\\\":\\n self.optimizer = tf.train.GradientDescentOptimizer(self.LEARN_RATE).\\\\\\n minimize(self.cost)\\n \\n elif self.OPTIM == \\\"Adam\\\":\\n self.optimizer = tf.train.AdamOptimizer(self.LEARN_RATE).\\\\\\n minimize(self.cost)\\n\\n # Merge all summaries for tensorboard\\n #self.tbsummaries = tf.summary.merge_all()\",\n \"def get_task_optimizer(self) -> torch.optim.Optimizer:\\n pass\",\n \"def __init__(self,\\n model: PreTrainedModel,\\n tokenizer: PreTrainedTokenizer,\\n optimizer: torch.optim.Optimizer,\\n n_epochs: int,\\n labels2ind: Dict[str, int],\\n scheduler: Optional[torch.optim.lr_scheduler.LambdaLR] = None,\\n device: str = 'cpu',\\n clipping: Optional[Union[int, float]] = None,\\n accumulate_grad_every: int = 1,\\n print_every: int = 10,\\n print_val_mistakes: bool = False,\\n output_dir: str = './'):\\n\\n self.tokenizer = tokenizer\\n self.model = model\\n self.optimizer = optimizer\\n self.scheduler = scheduler\\n self.n_epochs = n_epochs\\n self.labels2ind = labels2ind\\n self.inds2labels = {v: k for k, v in self.labels2ind.items()}\\n self.device = device\\n self.clipping = clipping\\n self.accumulate_grad_every = accumulate_grad_every\\n self.print_every = print_every\\n self.print_val_mistakes = print_val_mistakes\\n self.output_dir = output_dir\\n\\n os.makedirs(self.output_dir, exist_ok=True)\",\n \"def get_optimizer(train_model, params):\\n # TODO: Why are we looking for an entry in a list instead of directly matching the string?\\n if params.optimizer in [\\\"adam\\\"]:\\n param_optimizer = list(train_model.named_parameters())\\n # Set weight decay of bias and LayerNorm.weight to zero.\\n param_optimizer = [n for n in param_optimizer if 'pooler' not in n[0]]\\n no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\\n\\n optimizer_grouped_parameters = [\\n {'params': [p for n, p in param_optimizer if not any(\\n nd in n for nd in no_decay)], 'weight_decay': 0.01},\\n {'params': [p for n, p in param_optimizer if any(\\n nd in n for nd in no_decay)], 'weight_decay': 0.0}\\n ]\\n\\n if params.fp16:\\n print(\\\"SystemLog: Loading Apex and building the FusedAdam optimizer.\\\")\\n try:\\n from apex import amp\\n from apex.optimizers import FusedAdam\\n from apex.amp import _amp_state\\n except:\\n raise ImportError(\\n \\\"SystemLog: Please install apex from https://www.github.com/nvidia/apex to use distributed and fp16 training.\\\")\\n\\n if params.amp_opt_lvl not in ['O0', 'O1', 'O2', 'O3']:\\n raise ValueError(\\\"SystemLog: %s amp_opt_level is not supported\\\" % params.amp_opt_lvl)\\n\\n print(\\\"SystemLog: Using %s opt_level for Amp\\\" % params.amp_opt_lvl)\\n\\n optimizer = FusedAdam(optimizer_grouped_parameters,\\n lr=params.learning_rate,\\n bias_correction=False)\\n if params.loss_scale == 0:\\n train_model, optimizer = amp.initialize(train_model, optimizer, opt_level=params.amp_opt_lvl, loss_scale=\\\"dynamic\\\")\\n else:\\n train_model, optimizer = amp.initialize(train_model, optimizer, opt_level=params.amp_opt_lvl, loss_scale=params.loss_scale)\\n amp._amp_state.loss_scalers[0]._loss_scale = 2**20\\n else:\\n optimizer = BertAdam(optimizer_grouped_parameters,\\n lr=params.learning_rate,\\n warmup=params.warmup_proportion,\\n t_total=params.total_training_steps)\\n else:\\n # TODO: These parameters should be made configurable through global parameters/function arguments\\n optimizer = torch.optim.Adadelta(train_model.parameters(), lr=params.learning_rate, rho=0.95, eps=1e-08, weight_decay=0)\\n\\n return train_model, optimizer\",\n \"def get_optimizer(start_epoch, factor, opt_config, model):\\n optimizer = __optimizers[opt_config['optimizer']]\\n opt_params = {'parameter_list': model.parameters()}\\n for key in opt_config.keys():\\n if key == 'learning_rate':\\n lr = opt_config[key]\\n bo = [val*factor for val in lr['bound']]\\n decay_lr = fluid.dygraph.PiecewiseDecay(bo, lr['value'], start_epoch*factor)\\n opt_params['learning_rate'] = decay_lr\\n elif key == 'weight_decay':\\n regularization = fluid.regularizer.L2Decay(regularization_coeff=opt_config[key])\\n opt_params['regularization'] = regularization\\n elif key == 'momentum':\\n opt_params['momentum'] = opt_config[key]\\n\\n return optimizer(**opt_params)\",\n \"def load_model(model_name, environment_name):\\n ray.init(ignore_reinit_error=True)\\n # Fetch the specified model trainer.\\n model_module = importlib.import_module(\\n \\\"ray.rllib.agents.\\\" + alg2module[model_name])\\n # Load the trainer and return.\\n trainer = getattr(model_module, model_name + 'Trainer')\\n\\n env = None\\n if type(environment_name) == str:\\n if \\\"MiniGrid\\\" in environment_name:\\n import gym_minigrid.wrappers as gmw\\n # Need to adjust observation space.\\n minigrid_env = gym.make(environment_name)\\n env = gmw.ImgObsWrapper(minigrid_env)\\n else:\\n env = gym.make(environment_name)\\n else:\\n env = environment_name\\n\\n return trainer(env=environment_name)\",\n \"def configure_optimizers(self):\\n optimizer = torch.optim.Adam(\\n self.parameters(),\\n lr=self.hparams.learning_rate,\\n weight_decay=self.hparams.weight_decay,\\n )\\n return optimizer\",\n \"def new(self):\\n self.define_layers()\\n self.model = nn.Sequential(*self.layers)\\n self.model.cuda()\\n self.model = orthogonal_init(self.model)\\n\\n # Re-count N\\n self.count_params()\",\n \"def convert_to_torch_script(model, input_size):\\n model.eval()\\n\\n # An example input you would normally provide to your model's forward() method.\\n example = torch.rand(1, 3, input_size, input_size)\\n\\n # Use torch.jit.trace to generate a torch.jit.ScriptModule via tracing.\\n traced_script_module = torch.jit.trace(model, example)\\n\\n return traced_script_module\",\n \"def train(train_loader : torch.utils.data.DataLoader, model : nn.Module, criterion : nn.Module, optimizer : torch.optim.Optimizer) -> logger.Result:\",\n \"def set_optimizer(self, config):\\r\\n self.optimizer = optim.Adam(self.net.parameters(), config.lr)\\r\\n self.scheduler = optim.lr_scheduler.ExponentialLR(self.optimizer, config.lr_decay)\",\n \"def load_model(model: nn.Module, model_args: dict, model_weights: str, device: torch.device):\\n model = model(**model_args)\\n state_dict = torch.load(model_weights, map_location=device)\\n model.load_state_dict(state_dict[\\\"model\\\"])\\n return model\",\n \"def load(model_path: str):\\n model = torch.load(model_path)\\n model.eval()\\n return model\",\n \"def __init__(\\n self, weights_path: Optional[str], max_frames: int = 0, **model_kwargs,\\n ):\\n super().__init__()\\n max_frames = int(max_frames)\\n if max_frames < 0:\\n raise ValueError(f\\\"max_frames {max_frames} cannot be negative\\\")\\n self.max_frames = max_frames\\n self.model, self.optimizer = make_model(\\n weights_path=weights_path, **model_kwargs\\n )\",\n \"def select_optimizer(opt, model):\\n\\n if opt == 'msgd':\\n return optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\\n elif opt == 'adam':\\n return optim.Adam(model.parameters(), lr=0.001)\\n elif opt == 'rmsprop':\\n return optim.RMSprop(model.parameters(), lr=0.001)\\n elif opt == 'adagrad':\\n return optim.Adagrad(model.parameters(), lr=0.001)\\n else:\\n return optim.SGD(model.parameters(), lr=0.001)\",\n \"def _init_optimizer(self, optimizer):\\n if optimizer == \\\"rmsprop\\\":\\n self.optimizer = keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-06)\\n elif optimizer == \\\"adagrad\\\":\\n self.optimizer = keras.optimizers.Adagrad(lr=0.01, epsilon=1e-06)\\n elif optimizer == \\\"adadelta\\\":\\n self.optimizer = keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=1e-06)\\n elif optimizer == \\\"adam\\\":\\n self.optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\\n elif optimizer == \\\"adamax\\\":\\n self.optimizer = keras.optimizers.Adamax(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=1e-08) \\n elif hasattr(optimizer, __call__):\\n self.optimizer = optimizer\\n else:\\n print \\\"Error: unsupported optimizer %s\\\"%optimizer\\n sys.exit(0)\",\n \"def _init_optimizer(self, optimizer):\\n if optimizer == \\\"rmsprop\\\":\\n self.optimizer = keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-06)\\n elif optimizer == \\\"adagrad\\\":\\n self.optimizer = keras.optimizers.Adagrad(lr=0.01, epsilon=1e-06)\\n elif optimizer == \\\"adadelta\\\":\\n self.optimizer = keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=1e-06)\\n elif optimizer == \\\"adam\\\":\\n self.optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\\n elif optimizer == \\\"adamax\\\":\\n self.optimizer = keras.optimizers.Adamax(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=1e-08) \\n elif hasattr(optimizer, __call__):\\n self.optimizer = optimizer\\n else:\\n print \\\"Error: unsupported optimizer %s\\\"%optimizer\\n sys.exit(0)\",\n \"def optim_cls(self) -> type:\\n\\n return getattr(torch.optim, self._params.get(\\\"optimizer\\\", \\\"Adam\\\"))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75656193","0.7248476","0.7094529","0.70669323","0.6984369","0.68603814","0.67578644","0.66976243","0.6690973","0.66653234","0.66625184","0.66552","0.6637654","0.66292614","0.6535859","0.65118015","0.6485002","0.6414784","0.6320487","0.6311424","0.6306251","0.61640453","0.61441946","0.61401016","0.6127151","0.6099292","0.60934687","0.6090151","0.6079634","0.60610604","0.60554343","0.60450107","0.5977532","0.59358186","0.5917297","0.5915897","0.59027565","0.58937645","0.5862995","0.58558595","0.5843563","0.58394915","0.5831794","0.57926697","0.5783491","0.57375854","0.57089233","0.5702956","0.57006794","0.5697089","0.5679795","0.56763273","0.56739414","0.56324714","0.56317294","0.56090605","0.55861694","0.5580019","0.5579856","0.5579526","0.5575561","0.55751354","0.55649763","0.55331266","0.5526492","0.5523804","0.55183876","0.5508744","0.55018747","0.5491707","0.54802734","0.5461728","0.54499745","0.5447595","0.5441311","0.543569","0.542988","0.5426924","0.542245","0.54076505","0.54060507","0.54000556","0.5398662","0.53774637","0.5368346","0.53679585","0.535337","0.5350745","0.53373","0.5336137","0.53358835","0.5321679","0.5318685","0.5314642","0.5309358","0.530587","0.5302316","0.52985936","0.52985936","0.5296311"],"string":"[\n \"0.75656193\",\n \"0.7248476\",\n \"0.7094529\",\n \"0.70669323\",\n \"0.6984369\",\n \"0.68603814\",\n \"0.67578644\",\n \"0.66976243\",\n \"0.6690973\",\n \"0.66653234\",\n \"0.66625184\",\n \"0.66552\",\n \"0.6637654\",\n \"0.66292614\",\n \"0.6535859\",\n \"0.65118015\",\n \"0.6485002\",\n \"0.6414784\",\n \"0.6320487\",\n \"0.6311424\",\n \"0.6306251\",\n \"0.61640453\",\n \"0.61441946\",\n \"0.61401016\",\n \"0.6127151\",\n \"0.6099292\",\n \"0.60934687\",\n \"0.6090151\",\n \"0.6079634\",\n \"0.60610604\",\n \"0.60554343\",\n \"0.60450107\",\n \"0.5977532\",\n \"0.59358186\",\n \"0.5917297\",\n \"0.5915897\",\n \"0.59027565\",\n \"0.58937645\",\n \"0.5862995\",\n \"0.58558595\",\n \"0.5843563\",\n \"0.58394915\",\n \"0.5831794\",\n \"0.57926697\",\n \"0.5783491\",\n \"0.57375854\",\n \"0.57089233\",\n \"0.5702956\",\n \"0.57006794\",\n \"0.5697089\",\n \"0.5679795\",\n \"0.56763273\",\n \"0.56739414\",\n \"0.56324714\",\n \"0.56317294\",\n \"0.56090605\",\n \"0.55861694\",\n \"0.5580019\",\n \"0.5579856\",\n \"0.5579526\",\n \"0.5575561\",\n \"0.55751354\",\n \"0.55649763\",\n \"0.55331266\",\n \"0.5526492\",\n \"0.5523804\",\n \"0.55183876\",\n \"0.5508744\",\n \"0.55018747\",\n \"0.5491707\",\n \"0.54802734\",\n \"0.5461728\",\n \"0.54499745\",\n \"0.5447595\",\n \"0.5441311\",\n \"0.543569\",\n \"0.542988\",\n \"0.5426924\",\n \"0.542245\",\n \"0.54076505\",\n \"0.54060507\",\n \"0.54000556\",\n \"0.5398662\",\n \"0.53774637\",\n \"0.5368346\",\n \"0.53679585\",\n \"0.535337\",\n \"0.5350745\",\n \"0.53373\",\n \"0.5336137\",\n \"0.53358835\",\n \"0.5321679\",\n \"0.5318685\",\n \"0.5314642\",\n \"0.5309358\",\n \"0.530587\",\n \"0.5302316\",\n \"0.52985936\",\n \"0.52985936\",\n \"0.5296311\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70478994"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":4480,"cells":{"query":{"kind":"string","value":"Loads a checkpoint of an optimizer."},"document":{"kind":"string","value":"def try_load_checkpoint_for_optimizer(self) -> bool:\n\n if self._optimizer is None:\n raise ValueError(\"Optimizer must be created before optimizer checkpoint can be loaded.\")\n\n if not self.checkpoint_path:\n logging.warning(\"No checkpoint path provided.\")\n return False\n\n if not self.checkpoint_path.is_file():\n logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')\n return False\n\n logging.info(f\"Loading checkpoint {self.checkpoint_path}\")\n checkpoint = ModelAndInfo.read_checkpoint(self.checkpoint_path, self.config.use_gpu)\n\n try:\n state_dict = checkpoint[ModelAndInfo.OPTIMIZER_STATE_DICT_KEY]\n except KeyError:\n logging.error(f\"Key {ModelAndInfo.OPTIMIZER_STATE_DICT_KEY} not found in checkpoint\")\n return False\n\n self._optimizer.load_state_dict(state_dict)\n\n logging.info(f\"Loaded optimizer from checkpoint (epoch: {checkpoint[ModelAndInfo.EPOCH_KEY]})\")\n self.checkpoint_epoch = checkpoint[ModelAndInfo.EPOCH_KEY]\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\n print(\"Load checkpoint from: {}\".format(path))\n state_dict, optimizer_state = _load(path)\n\n model.load_dict(state_dict)\n if not reset_optimizer and optimizer is not None:\n if optimizer_state is not None:\n print(\"[loading] Load optimizer state from {}\".format(path))\n optimizer.load(optimizer_state)\n\n return model","def load_checkpoint(checkpoint, model, optimizer=None):\n model_state_dict, optimizer_state_dict = torch.load(checkpoint)\n model.load_state_dict(model_state_dict)\n\n if optimizer is not None:\n optimizer.load_state_dict(optimizer_state_dict)","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint)\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load_checkpoint(checkpoint_path, model, optimizer=None):\n if not os.path.exists(checkpoint_path):\n raise IOError(f\"Checkpoint '{checkpoint_path}' does not exist\")\n\n state = torch.load(checkpoint_path)\n try:\n model.load_state_dict(state['model_state_dict'])\n except BaseException as e:\n print('Failed to do something: ' + str(e))\n\n if optimizer is not None:\n try:\n optimizer.load_state_dict(state['optimizer_state_dict'])\n except Exception as e:\n print(e)\n\n return state","def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\n self.model.load_state_dict(checkpoint[\"model_state_dict\"])\n self.optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n return self","def load_checkpoint(checkpoint_path, model, optimizer=None,\n model_key='model_state_dict', optimizer_key='optimizer_state_dict'):\n if not os.path.exists(checkpoint_path):\n raise IOError(f\"Checkpoint '{checkpoint_path}' does not exist\")\n\n state = torch.load(checkpoint_path, map_location='cpu')\n model.load_state_dict(state[model_key])\n\n if optimizer is not None:\n optimizer.load_state_dict(state[optimizer_key])\n\n return state","def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\n print(\"Loading checkpoint: {}\".format(checkpoint_path))\n state = torch.load(checkpoint_path)\n self.model.load_state_dict(state['state_dict'])\n self.optimizer.load_state_dict(state['optim_dict'])\n\n if continue_from_epoch:\n self.epoch = state['epoch']","def load_checkpoint(checkpoint_path, model, optimizer=None):\n if not os.path.exists(checkpoint_path):\n raise IOError(\"Checkpoint '{}' does not exist\".format(checkpoint_path))\n\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else 'cpu')\n state = torch.load(checkpoint_path, map_location=\"cuda:0\")\n model.load_state_dict(state['model_state_dict'])\n\n if optimizer is not None:\n optimizer.load_state_dict(state['optimizer_state_dict'])\n\n return state","def _load(checkpoint_path):\n state_dict, optimizer_state = dg.load_persistables(dirname=checkpoint_path)\n return state_dict, optimizer_state","def load_checkpoint(args, trainer, epoch_itr):\n os.makedirs(os.path.join(args.save_dir, 'checkpoints'), exist_ok=True)\n checkpoint_path = os.path.join(args.save_dir, 'checkpoints', args.restore_file)\n if os.path.isfile(checkpoint_path):\n extra_state = trainer.load_checkpoint(checkpoint_path)\n if extra_state is not None:\n # replay train iterator to match checkpoint\n epoch_itr.load_state_dict(extra_state['train_iterator'])\n\n print('| loaded checkpoint {} (epoch {} @ {} updates)'.format(\n checkpoint_path, epoch_itr.epoch, trainer.get_num_updates()))\n\n trainer.lr_step(epoch_itr.epoch)\n trainer.lr_step_update(trainer.get_num_updates())\n if 'best' in extra_state:\n save_checkpoint.best = extra_state['best']","def load_checkpoint(tag, params, model):\r\n file_name = os.path.join(\"saved_models\", params.path, tag + \".pt\")\r\n logger.info(\"Load checkpoint from %s\" % file_name)\r\n if os.path.exists(file_name):\r\n checkpoint = torch.load(file_name, map_location='cpu')\r\n params.training_id = checkpoint['training_id']\r\n logger.info(checkpoint['training_id'])\r\n model.global_step = checkpoint['global_step']\r\n model.load_state_dict(checkpoint['model'])\r\n for i, optimizer in enumerate(model.optimizers):\r\n optimizer.load_state_dict(checkpoint['optimizers'][i])\r\n else:\r\n raise Exception(\"Checkpoint not found.\")","def load_ckp(checkpoint_fpath, model, optimizer, device):\n\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\n model.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n valid_acc = checkpoint['valid_acc'] \n return model, optimizer, checkpoint['epoch'], valid_acc","def load(loadname, checkpoint=None):\n ckpt_dir = \"./models/tf_ckpt_\" + loadname + \"/\"\n if checkpoint is not None:\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\n status.assert_consumed()\n print(\"Loaded checkpoint\")\n else:\n print(\"Not Loading any checkpoint\")\n print(\"Starting training from initial configuration\")","def load_checkpoint(self):\n checkpoin_path = self.get_checkpoint_path()\n _logger.info('Load checkpoint ignored by tuner, checkpoint path: %s', checkpoin_path)","def load_checkpoint(self, session, model_dir):\n assert self.params.cp_load == True, (\"cp_load must be set to true to load a checkpoint\")\n self.loader.restore(session, model_dir)","def load_checkpoint(self, checkpoint_path=None):\n if checkpoint_path is None:\n checkpoint_path = self.get_latest_path()\n\n if os.path.isfile(checkpoint_path):\n key = 'cuda' if torch.cuda.is_available() else 'cpu'\n checkpoint = torch.load(checkpoint_path, map_location=key)\n self.network.load_state_dict(checkpoint['network'])\n self.network_target.load_state_dict(checkpoint['network_target'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n print('checkpoint loaded at {}'.format(checkpoint_path))\n else:\n raise OSError(\"Checkpoint file not found.\")","def load_pretrained(model, fname, optimizer=None):\n if os.path.isfile(fname):\n print(\"=> loading checkpoint '{}'\".format(fname))\n checkpoint = torch.load(fname)\n model.load_state_dict(checkpoint['state_dict'])\n if optimizer is not None:\n optimizer.load_state_dict(checkpoint['optimizer'])\n return model, optimizer, checkpoint['epoch']\n else:\n return model\n else:\n raise Exception(\"=> no checkpoint found at '{}'\".format(fname))","def load_checkpoint(ckpt_path):\n checkpoint = None\n if ckpt_path:\n logger.info(\"Loading checkpoint from %s\" % ckpt_path)\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\"cpu\"))\n\n if \"model\" in checkpoint.keys():\n # This preserves backward-compat for models using customed layernorm\n def fix_key(s):\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.b_2\", r\"\\1.layer_norm\\2.bias\", s\n )\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.a_2\", r\"\\1.layer_norm\\2.weight\", s\n )\n return s\n\n checkpoint[\"model\"] = {\n fix_key(k): v for k, v in checkpoint[\"model\"].items()\n }\n # Force add_ffnbias to True if bias found in model w_1 keys\n for key in checkpoint[\"model\"].keys():\n if \"w_1.bias\" in key:\n checkpoint[\"opt\"].add_ffnbias = True\n\n if not hasattr(checkpoint[\"opt\"], \"num_kv\"):\n checkpoint[\"opt\"].num_kv = 0\n if not hasattr(checkpoint[\"opt\"], \"add_ffnbias\"):\n checkpoint[\"opt\"].add_ffnbias = False\n if not hasattr(checkpoint[\"opt\"], \"parallel_residual\"):\n checkpoint[\"opt\"].parallel_residual = False\n if not hasattr(checkpoint[\"opt\"], \"shared_layer_norm\"):\n checkpoint[\"opt\"].shared_layer_norm = False\n if not hasattr(checkpoint[\"opt\"], \"use_ckpting\"):\n checkpoint[\"opt\"].use_ckpting = []\n if not hasattr(checkpoint[\"opt\"], \"relative_positions_buckets\"):\n checkpoint[\"opt\"].relative_positions_buckets = 0\n if not hasattr(checkpoint[\"opt\"], \"parallel_mode\"):\n checkpoint[\"opt\"].parallel_mode = \"data_parallel\"\n if not hasattr(checkpoint[\"opt\"], \"norm_eps\"):\n checkpoint[\"opt\"].norm_eps = 1e-6\n\n # fix v2 compatibility\n if \"generator\" in checkpoint.keys() and checkpoint[\"generator\"]:\n if \"0.weight\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"weight\"] = checkpoint[\"generator\"].pop(\n \"0.weight\"\n )\n if \"0.bias\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"bias\"] = checkpoint[\"generator\"].pop(\"0.bias\")\n # end of patch for backward compatibility\n\n return checkpoint","def load_from_checkpoint(self, path):\n print(f'# loading trainer state from {path}')\n checkpoint = torch.load(path)\n self.load(checkpoint)","def load(self, path):\n checkpoint = torch.load(path)\n self.load_state_dict(checkpoint['model_state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])","def load(self, path):\n checkpoint = torch.load(path)\n self.load_state_dict(checkpoint['model_state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])","def load_model(path, model, optimizer):\n print(\"LOADING MODEL...\")\n ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)\n status = ckpt.restore(tf.train.latest_checkpoint(path))\n ckpt_manager = tf.train.CheckpointManager(\n checkpoint=ckpt, \n directory=FLAGS.model_dir, \n max_to_keep=3 \n )\n return model, optimizer, ckpt, ckpt_manager","def load_checkpoint(self, filename, load_optim=True):\n extra_state, optim_history, last_optim_state = \\\n utils.load_model_state(filename, self.get_model())\n\n if last_optim_state is not None:\n # rebuild optimizer after loading model, since params may have changed\n #self.optimizer = optim.build_optimizer(self.args, self.model.parameters())\n self.lr_scheduler = lr_scheduler.build_lr_scheduler(self.args, self.optimizer)\n\n if load_optim:\n self._optim_history = optim_history\n # only reload optimizer and lr_scheduler if they match\n last_optim = self._optim_history[-1]\n if last_optim['criterion_name'] == self.criterion.__class__.__name__:\n self.lr_scheduler.load_state_dict(last_optim['lr_scheduler_state'])\n if last_optim['optimizer_name'] == self.optimizer.__class__.__name__:\n self.optimizer.load_state_dict(last_optim_state)\n\n self._num_updates = last_optim['num_updates']\n\n return extra_state","def load_model_from_checkpoint(self, path: str):\n ckpt = torch.load(path, map_location='cpu')\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\n self.net_q.head.load_state_dict(ckpt['head'])\n self.net_ps.load_state_dict(ckpt['net_ps'])\n self.net_k.load_state_dict(ckpt['net_k'])\n self.queue.load_state_dict(ckpt['queue'])\n self.optimizer.load_state_dict(ckpt['optimizer'])\n if 'scheduler' in ckpt:\n self.scheduler.load_stae_dict(ckpt['scheduler'])\n self.move_optimizer_states(self.optimizer, self.local_rank)","def load_checkpoint(self, model, optimizers):\n self.epoch = get_last_epoch(self.log_path)\n\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\n model.load_state_dict(model_state_dict)\n\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\n for opt_ind in range(len(optimizers)):\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\n\n schedulers = load_sched(optimizers, self.epoch)\n\n return model, optimizers, schedulers","def load_checkpoint(self, label):\n model_dir = os.path.join(\n config.results_dir, config.experiment_name, 'checkpoints')\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\n\n print(\"Loading model from {}\".format(model_file))\n model_dict = torch.load(model_file)\n\n self.use_cuda = model_dict['use_cuda']\n if self.use_cuda:\n self.net.cuda()\n\n self.net.load_state_dict(model_dict['net_state_dict'])","def LoadProgramState(self, restored_checkpoint_path=None, sess=None):\n pass","def _resume_checkpoint(self, resume_path, model, optimizer):\n if not resume_path:\n return model, optimizer\n\n self.logger.info(f'Loading checkpoint: {resume_path}')\n checkpoint = torch.load(resume_path)\n model.load_state_dict(checkpoint['state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed.\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\n self.logger.warning(\"Warning: Optimizer type given in config file is different from \"\n \"that of checkpoint. Optimizer parameters not being resumed.\")\n else:\n optimizer.load_state_dict(checkpoint['optimizer'])\n\n self.logger.info(f'Checkpoint \"{resume_path}\" loaded')\n return model, optimizer","def load_model(self, checkpoint):\n print(f'Load parameters from {checkpoint}')\n epoch = re.match(r\"[0-9]*\", os.path.basename(checkpoint)).group(0)\n self.epoch_i = int(epoch)\n self.model.load_state_dict(torch.load(checkpoint))","def load_checkpoint(self):\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\n try:\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\n ckpt = torch.load(self.params.resume_from)\n self.epoch = ckpt['epoch']\n try:\n self.train_loss = ckpt['train_loss']\n self.val_loss = ckpt['val_loss']\n except:\n self.train_loss = []\n self.val_loss = []\n self.network.load_state_dict(ckpt['state_dict'])\n self.opt.load_state_dict(ckpt['optimizer'])\n LOG('Checkpoint Loaded!')\n LOG('Current Epoch: %d' % self.epoch)\n self.ckpt_flag = True\n except:\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\n else:\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')","def load_ckpt(self, name=None):\r\n name = name if name == 'latest' else \"ckpt_epoch{}\".format(name)\r\n load_path = os.path.join(self.model_dir, \"{}.pth\".format(name))\r\n if not os.path.exists(load_path):\r\n raise ValueError(\"Checkpoint {} not exists.\".format(load_path))\r\n\r\n checkpoint = torch.load(load_path)\r\n print(\"Checkpoint loaded from {}\".format(load_path))\r\n if isinstance(self.net, nn.DataParallel):\r\n self.net.module.load_state_dict(checkpoint['model_state_dict'])\r\n else:\r\n self.net.load_state_dict(checkpoint['model_state_dict'])\r\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\r\n self.scheduler.load_state_dict(checkpoint['scheduler_state_dict'])\r\n self.clock.restore_checkpoint(checkpoint['clock'])","def load_checkpoint(self, checkpoint_path: str, *args, **kwargs) -> Dict:\n return torch.load(checkpoint_path, *args, **kwargs)","def load_checkpoint(self, checkpoint_path: str, *args, **kwargs) -> Dict:\n return torch.load(checkpoint_path, *args, **kwargs)","def load_checkpoint_train(cpdir, model, optimizer):\n start_epoch = 0\n start_global_step = 0\n if cpdir is not None:\n start_global_step, start_epoch = load_checkpoint(\n cpdir, model, optimizer)\n start_global_step += 1\n start_epoch += 1\n return start_global_step, start_epoch","def load_checkpoint(cfg, args):\n checkpoint_iteration = args.checkpoint\n bucket = connect_to_bucket(args.bucket)\n # load actual checkpoint\n if not os.path.isdir(cfg.OUTPUT_DIR):\n os.mkdir(cfg.OUTPUT_DIR)\n blob = bucket.blob(cfg.OUTPUT_DIR + \"/model_\" + str(checkpoint_iteration) + \".pth\")\n blob.download_to_filename(cfg.OUTPUT_DIR + \"/model_\" + str(checkpoint_iteration) + \".pth\")\n if args.resume:\n # also write last checkpoint file for when --resume statement, model gets checkpoint name from this file\n with open(cfg.OUTPUT_DIR + \"/last_checkpoint\", \"w\") as file:\n file.write(\"model_\" + str(checkpoint_iteration) + \".pth\")\n # return statement not clean, but useful for inference code\n return checkpoint_iteration, bucket","def load_from_path(self, checkpoint_dir):\n\n vars = self.save_var_names\n saver = tf.train.Saver(vars)\n\n def load_aux(ckpt_path):\n \"\"\"Helper function to not repeat the same code in the following lines.\"\"\"\n\n ckpt_name = os.path.basename(ckpt_path)\n saver.restore(self.sess, ckpt_path)\n counter = int(next(re.finditer(\"(\\d+)(?!.*\\d)\", ckpt_name)).group(0))\n self.counter = counter\n print(\" [*] Loaded {}\".format(ckpt_name))\n return True, counter\n\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\n try:\n if ckpt and ckpt.model_checkpoint_path:\n ckpt_name = os.path.basename(ckpt.model_checkpoint_path)\n return load_aux(os.path.join(checkpoint_dir, ckpt_name))\n else:\n print(\n \" [!] Failed to find a checkpoint within directory {}\".format(\n FLAGS.ckpt_path))\n return False, 0\n except:\n print(\" [!] Failed to find a checkpoint, Exception!\")\n return False, 0","def load(cls, path):\n print(f'load checkpoint from {path}')\n if torch.cuda.is_available():\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\n else:\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\n \n # model.flatten_parameters() # make RNN parameters contiguous\n optimizer = resume_checkpoint['optimizer']\n return Checkpoint(\n model=model, \n optimizer=optimizer,\n epoch=resume_checkpoint['epoch'],\n path=path\n )","def load_checkpoint(self, checkpoint: str, **kwargs) -> None:\n with open(checkpoint, \"rb\") as f:\n state = SafePickle.load(f)\n\n state_id = ray.put(state)\n ray.get([worker.set_state.remote(state_id, **kwargs) for worker in self.remote_workers])","def opt_from_checkpoint(\n checkpoint_path: str,\n config_path: Optional[str] = None,\n extra_bindings=tuple([])\n) -> Optimizer:\n\n if config_path is None:\n config_path = \"/\".join(checkpoint_path.split(\"/\")[:-1]) + \"/config.gin\"\n\n logging.info(\"Restoring configs from: %s\", config_path)\n with gin.unlock_config():\n scope = f\"opt_from_checkpoint__{str(uuid.uuid4()).replace('-', '_')}\"\n with gin.config_scope(None):\n with gin.config_scope(scope):\n if config_path:\n with file_open(config_path, \"rb\") as f:\n content = bytes(f.read()).decode(\"utf-8\")\n\n # gin writes out multi line sometimes, undo this.\n content = content.replace(\"\\\\\\n\", \"\")\n\n def maybe_add_scope(c):\n # filter out train as this overlaps with outer_training.\n if c.startswith(\"#\"):\n return None\n if \"=\" in c:\n return scope + \"/\" + c\n return c\n\n bindings = [maybe_add_scope(c) for c in content.split(\"\\n\")]\n bindings = [b for b in bindings if b]\n bindings = bindings + [maybe_add_scope(c) for c in extra_bindings]\n\n logging.info(\"Parsing bindings\")\n for b in bindings:\n logging.info(b)\n print(b)\n gin.parse_config(bindings, skip_unknown=True)\n\n configurable = gin.query_parameter(f\"{scope}/run_train.lopt\")\n if isinstance(configurable, gin.config._UnknownConfigurableReference): # pylint: disable=protected-access\n raise ValueError(\"Gin couldn't find the learned optimizer in current\"\n \" imports. Did you forget to import the module?\")\n\n # with summary.summary_scope(\"opt_from_checkpoint\"):\n lopt = configurable.configurable.wrapped()\n theta = lopt.init(jax.random.PRNGKey(0))\n logging.info(f\"Restoring checkpoint {checkpoint_path}\") # pylint: disable=logging-fstring-interpolation\n ckpt = ParameterCheckpoint(theta, \"\", 0)\n ckpt = load_state(checkpoint_path, ckpt)\n opt = lopt.opt_fn(ckpt.params)\n return opt\n # wrapped = _GinScopeClass(opt, scope)\n # For now, just add the lopt to the returned class.\n # TODO(lmetz) change this api to return a more structured class?\n # wrapped.lopt = lopt\n # return wrapped # type: ignore","def load_checkpoint(self, path: str = '', train: bool = True) -> int:\n\n if not path:\n dir_ = os.path.dirname(os.path.realpath('__file__'))\n path = os.path.join(dir_, 'model.pt')\n\n try:\n ckpt = torch.load(path)\n except FileNotFoundError:\n return 0\n else:\n print('Loaded model at epoch: ', end='')\n\n self.load_state_dict(ckpt['model_state_dict'])\n self.actor_optimizer.load_state_dict(ckpt['ac_optim_dict'])\n self.critic_optimizer.load_state_dict(ckpt['critic_optim_dict'])\n epoch = ckpt['epoch']\n\n print(epoch)\n\n if not train:\n self.eval()\n else:\n self.train()\n\n return epoch","def try_create_optimizer_and_load_from_checkpoint(self) -> bool:\n self.create_optimizer()\n if self.checkpoint_path:\n return self.try_load_checkpoint_for_optimizer()\n return True","def reload_checkpoint(self):\n checkpoint_path = os.path.join(self.params.dump_path, 'checkpoint.pth')\n if not os.path.isfile(checkpoint_path):\n if self.params.reload_checkpoint == '':\n return\n else:\n checkpoint_path = self.params.reload_checkpoint\n assert os.path.isfile(checkpoint_path)\n logger.warning(\"Reloading checkpoint from %s ...\" % checkpoint_path)\n data = torch.load(checkpoint_path, map_location='cpu')\n\n # reload model parameters\n for name in self.MODEL_NAMES:\n getattr(self, name).load_state_dict(data[name])\n\n # reload optimizers\n for name in self.optimizers.keys():\n if False: # AMP checkpoint reloading is buggy, we cannot do that - TODO: fix - https://github.com/NVIDIA/apex/issues/250\n logger.warning(\"Reloading checkpoint optimizer %s ...\" % name)\n else: # instead, we only reload current iterations / learning rates\n logger.warning(\"Not reloading checkpoint optimizer %s.\" % name)\n for group_id, param_group in enumerate(self.optimizers[name].param_groups):\n if 'num_updates' not in param_group:\n logger.warning(\"No 'num_updates' for optimizer %s.\" % name)\n continue\n logger.warning(\"Reloading 'num_updates' and 'lr' for optimizer %s.\" % name)\n param_group['num_updates'] = data['%s_optimizer' % name]['param_groups'][group_id]['num_updates']\n param_group['lr'] = self.optimizers[name].get_lr_for_step(param_group['num_updates'])\n\n # reload main metrics\n self.epoch = data['epoch'] + 1\n self.n_total_iter = data['n_total_iter']\n self.best_metrics = data['best_metrics']\n self.best_stopping_criterion = data['best_stopping_criterion']\n logger.warning(\"Checkpoint reloaded. Resuming at epoch %i / iteration %i ...\" % (self.epoch, self.n_total_iter))","def load_ckpt(saver, sess, ckpt_dir=\"train\"):\n while True:\n try:\n latest_filename = \"checkpoint_best\" if ckpt_dir==\"eval\" else None\n ckpt_dir = os.path.join(FLAGS.log_root, ckpt_dir)\n ckpt_state = tf.train.get_checkpoint_state(ckpt_dir, latest_filename=latest_filename)\n tf.logging.info('Loading checkpoint %s', ckpt_state.model_checkpoint_path)\n saver.restore(sess, ckpt_state.model_checkpoint_path)\n return ckpt_state.model_checkpoint_path\n except:\n tf.logging.info(\"Failed to load checkpoint from %s. Sleeping for %i secs...\", ckpt_dir, 10)\n time.sleep(10)","def load_ckpt(saver, sess, ckpt_dir=\"train\"):\n while True:\n try:\n latest_filename = \"checkpoint_best\" if ckpt_dir == \"eval\" else None\n ckpt_dir = os.path.join(FLAGS.log_root, ckpt_dir)\n ckpt_state = tf.train.get_checkpoint_state(ckpt_dir, latest_filename=latest_filename)\n tf.logging.info('Loading checkpoint %s', ckpt_state.model_checkpoint_path)\n saver.restore(sess, ckpt_state.model_checkpoint_path)\n return ckpt_state.model_checkpoint_path\n except:\n tf.logging.info(\"Failed to load checkpoint from %s. Sleeping for %i secs...\", ckpt_dir, 10)\n time.sleep(10)","def load_checkpoint(model, save_path):\n model.load_state_dict(torch.load(save_path))","def load(self, checkpoint_dir):\n print(\"\\nReading Checkpoints.....\\n\\n\")\n model_dir = \"%s\" % (\"cnn\") # give the model name by label_size\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir)\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\n \n # Check the checkpoint is exist\n if ckpt and ckpt.model_checkpoint_path:\n ckpt_path = str(ckpt.model_checkpoint_path) # convert the unicode to string\n self.saver.restore(self.sess, os.path.join(os.getcwd(), ckpt_path))\n print(\"\\n Checkpoint Loading Success! %s\\n\\n\"% ckpt_path)\n else:\n print(\"\\n! Checkpoint Loading Failed \\n\\n\")","def load_model(agent, optimizer, model_file):\n checkpoint = torch.load(model_file)\n episode = checkpoint['epoch']\n agent.load_state_dict(checkpoint['model_state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n return episode","def load_from_checkpoint(results_dir, load_fn, args):\n ckpt_dir = os.path.join(results_dir, \"tb\", \"version_0\", \"checkpoints\")\n files = os.listdir(ckpt_dir)\n assert len(files) > 0, \"Checkpoint directory is empty\"\n ckpt_path = os.path.join(ckpt_dir, files[-1])\n model = load_fn(checkpoint_path=ckpt_path, args=args)\n return model","def load(self):\r\n checkpoint = torch.load(self.checkpoint_path,\r\n map_location=self.device)\r\n self.load_state_dict(checkpoint)\r\n del checkpoint","def load(self, checkpoint_dir=None):\n\n if checkpoint_dir is None:\n checkpoint_dir = FLAGS.checkpoint_dir\n\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n\n return self.load_from_path(checkpoint_dir)","def load(self):\n checkpoint = torch.load(self.checkpoint_path,\n map_location=self.net.device)\n self.load_state_dict(checkpoint)\n del checkpoint","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.monitor_best = checkpoint['monitor_best']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n if self.with_cuda:\n for state in self.optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = v.cuda(torch.device('cuda'))\n self.train_logger = checkpoint['logger']\n #self.config = checkpoint['config']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def load_training_checkpoint(args, model, PATH, ckpt_id):\r\n logger = args.logger\r\n _, checkpoint_state_dict = model.network.load_checkpoint(PATH, ckpt_id)\r\n epoch = checkpoint_state_dict['epoch']\r\n last_global_step = checkpoint_state_dict['last_global_step']\r\n last_global_data_samples = checkpoint_state_dict[\r\n 'last_global_data_samples']\r\n del checkpoint_state_dict\r\n return (epoch, last_global_step, last_global_data_samples)","def _resume_checkpoint(self, resume_path):\n resume_path = str(resume_path)\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n\n # load architecture params from checkpoint.\n if checkpoint['config']['model'] != self.config['model']:\n self.logger.warning(\"Warning: Architecture configuration given in config file is different from that of \"\n \"checkpoint. This may yield an exception while state_dict is being loaded.\")\n self.model.load_state_dict(checkpoint['state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed.\n if checkpoint['config']['trainer']['optimizer']['type'] != self.config['trainer']['optimizer']['type']:\n self.logger.warning(\"Warning: Optimizer type given in config file is different from that of checkpoint. \"\n \"Optimizer parameters not being resumed.\")\n else:\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n self.logger.info(\"Checkpoint loaded. Resume from epoch {}\".format(self.start_epoch))","def load_model(model, checkpoint_path: str): \r\n checkpoint = torch.load(checkpoint_path)\r\n model.load_state_dict(checkpoint['model'])\r\n epoch = checkpoint['epoch']\r\n print('Loaded model from {}, epoch {}'.format(checkpoint_path, epoch))","def restore(self, checkpoint_path):\n start_time = time.time()\n latest_checkpoint = train_util.get_latest_chekpoint(checkpoint_path)\n if latest_checkpoint is not None:\n checkpoint = tf.train.Checkpoint(model=self)\n checkpoint.restore(latest_checkpoint).expect_partial()\n logging.info('Loaded checkpoint %s', latest_checkpoint)\n logging.info('Loading model took %.1f seconds', time.time() - start_time)\n else:\n logging.info('Could not find checkpoint to load at %s, skipping.',\n checkpoint_path)","def load_model(self, ckpt_fn):\n checkpoint = torch.load(ckpt_fn)\n self.net_.load_state_dict(checkpoint[\"model\"])\n self.optimizer_.load_state_dict(checkpoint[\"optimizer\"])\n self.epoch_ = checkpoint[\"epoch\"]\n self.global_step_ = checkpoint[\"global_step\"]\n self.model_samples_ = deque(checkpoint[\"model_samples\"])\n self.sampler.load_state_dict(checkpoint[\"sampler_state\"])\n self.ais_loss.load_state_dict(checkpoint[\"ais_state\"])\n self.replay_prob = checkpoint[\"replay_prob\"]\n self.max_replay = checkpoint[\"max_replay\"]","def load_checkpoint(checkpoint_dir, epoch, iteration):\n path = opj(checkpoint_dir, str(epoch) + '.' + str(iteration) + '.ckpt')\n if not os.path.isfile(path):\n raise Exception(\"Checkpoint in epoch %d doesn't exist :sob:\" % epoch)\n\n checkpoint = torch.load(path)\n start_epoch = checkpoint['epoch']\n state_dict = checkpoint['state_dict']\n start_iteration = checkpoint['iteration']\n\n assert iteration == start_iteration\n return start_epoch, start_iteration, state_dict","def load_model (checkpoint_path, model, opt_fn=None, loss_fn=None, epoch=None):\n\n if not os.path.exists(checkpoint_path):\n raise Exception (\"The {} does not exist!\".format(checkpoint_path))\n\n ckpt = torch.load(checkpoint_path)\n model.load_state_dict(ckpt['model_state_dict'])\n\n if opt_fn is not None and loss_fn is not None:\n opt_fn.load_state_dict(ckpt['optimizer_state_dict'])\n epoch = ckpt['epoch']\n loss_fn = ckpt['loss']\n return model, opt_fn, loss_fn, epoch\n else:\n return model","def load_checkpoint(path):\n\n # Get the model name\n model_name = path.split('-')[0]\n assert (model_name in ['vgg16', 'resnet50'\n ]), \"Path must have the correct model name\"\n\n # Load in checkpoint\n checkpoint = torch.load(path)\n\n if model_name == 'vgg16':\n model = models.vgg16(pretrained=True)\n # Make sure to set parameters as not trainable\n for param in model.parameters():\n param.requires_grad = False\n model.classifier = checkpoint['classifier']\n\n elif model_name == 'resnet50':\n model = models.resnet50(pretrained=True)\n # Make sure to set parameters as not trainable\n for param in model.parameters():\n param.requires_grad = False\n model.fc = checkpoint['fc']\n\n # Load in the state dict\n model.load_state_dict(checkpoint['state_dict'])\n\n total_params = sum(p.numel() for p in model.parameters())\n print(f'{total_params:,} total parameters.')\n total_trainable_params = sum(\n p.numel() for p in model.parameters() if p.requires_grad)\n print(f'{total_trainable_params:,} total gradient parameters.')\n\n # Move to gpu\n if multi_gpu:\n model = nn.DataParallel(model)\n\n if train_on_gpu:\n model = model.to('cuda')\n\n # Model basics\n model.class_to_idx = checkpoint['class_to_idx']\n model.idx_to_class = checkpoint['idx_to_class']\n model.epochs = checkpoint['epochs']\n\n # Optimizer\n optimizer = checkpoint['optimizer']\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n\n return model, optimizer","def load_checkpoint(self, checkpoint_dir):\r\n\r\n if not os.path.exists(checkpoint_dir):\r\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\r\n\r\n path = os.path.join(checkpoint_dir, 'model.pt')\r\n self.model.load_state_dict(torch.load(path, self.device))\r\n self.update()","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.monitor_best = checkpoint['monitor_best']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n self.train_logger = checkpoint['logger']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def unpack_checkpoint(\n self,\n checkpoint: Dict,\n model=None,\n criterion=None,\n optimizer=None,\n scheduler=None,\n **kwargs,\n ) -> None:\n super().unpack_checkpoint(\n checkpoint,\n model=model,\n criterion=criterion,\n optimizer=optimizer,\n scheduler=scheduler,\n **kwargs,\n )\n\n # NOTE: propper way to load state, docs:\n # https://nvidia.github.io/apex/amp.html#checkpointing\n if \"amp\" in checkpoint:\n amp.load_state_dict(checkpoint[\"amp\"])","def unpack_checkpoint(\n self,\n checkpoint: Dict,\n model=None,\n criterion=None,\n optimizer=None,\n scheduler=None,\n **kwargs,\n ) -> None:\n super().unpack_checkpoint(\n checkpoint,\n model=model,\n criterion=criterion,\n optimizer=optimizer,\n scheduler=scheduler,\n **kwargs,\n )\n\n # NOTE: propper way to load state, docs:\n # https://nvidia.github.io/apex/amp.html#checkpointing\n if \"amp\" in checkpoint:\n amp.load_state_dict(checkpoint[\"amp\"])","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.mnt_best = checkpoint['monitor_best']\n\n # load model params from checkpoint.\n if checkpoint['config']['name'] != self.config['name']:\n self.logger.warning(\n 'Warning: Architecture configuration given in config file is different from that of checkpoint. ' + \\\n 'This may yield an exception while state_dict is being loaded.')\n self.model.load_state_dict(checkpoint['model_state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed. \n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\n self.logger.warning('Warning: Optimizer type given in config file is different from that of checkpoint. ' + \\\n 'Optimizer parameters not being resumed.')\n self.optimizer.load_state_dict(checkpoint['model_optimizer'])\n\n # load scheduler state from checkpoint only when scheduler type is not changed\n if checkpoint['config']['scheduler']['type'] != self.config['scheduler']['type']:\n self.logger.warning('Warning: Scheduler type given in config file is different from that of checkpoint. ' + \\\n 'Scheduler parameters not being resumed.')\n self.scheduler.load_state_dict(checkpoint['model_scheduler'])\n\n self.train_logger = checkpoint['logger']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def load_checkpoint(self, model):\n print(f\"load model {self.save_model_path}\")\n model.load_state_dict(torch.load(self.save_model_path))","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.monitor_best = checkpoint['monitor_best']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n # 将参数全部放入GPU\n if self.with_cuda:\n for state in self.optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = v.cuda(self.device)\n self.train_logger = checkpoint['logger']\n self.config = checkpoint['config']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def load_checkpoint(model, model_name='model', validation_id=None):\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\n _load_model(model.module if type(model) is torch.nn.DataParallel else model, model_name, path=path, reload=True)","def load_from_checkpoint(self, chkpt, section=None):\n if section is None:\n section = self.name\n self.load_state_dict(chkpt[section])","def load_G(self, G_checkpoint):\n checkpoint = torch.load(G_checkpoint)\n self.G.load_state_dict(checkpoint['gnet'])\n self.gen_optim.load_state_dict(checkpoint['gopt'])","def load_ckpt(args):\n net = model.Model.load_from_checkpoint(args.ckpt)\n net = net.eval().requires_grad_(False).to(args.device)\n return net","def load_snapshot(device, net, snapshot_name, optimizer=None):\n\ttry:\n\t\tcheckpoint = torch.load(snapshot_name+'.pth', map_location=device)\n\t\tnet.load_state_dict(checkpoint['model_state_dict'])\n\t\tif optimizer:\n\t\t\trestore_optimizer(optimizer, checkpoint)\n\texcept:\n\t\tcheckpoint = None\t\n\treturn checkpoint","def load_checkpoint(checkpoint_file: pl.Path) -> Optional[Dict[str, Any]]:\n if checkpoint_file.exists():\n logger.info(f\"Loading checkpoint {checkpoint_file}.\")\n checkpoint = torch.load(str(checkpoint_file))\n logger.info(f\"Done loading checkpoint from epoch {checkpoint['epoch']}.\")\n else:\n logger.warning(f\"No {checkpoint_file} checkpoint file found. Starting normal.\")\n return checkpoint","def load_checkpoint(self, checkpoint_path: Union[str, Path]) -> Dict[str, Any]:\n # TODO: move to CheckpointIO\n torch.cuda.empty_cache()\n checkpoint_path = inject_model_parallel_rank(checkpoint_path)\n return self.checkpoint_io.load_checkpoint(checkpoint_path)","def load_training(saver, session, load_dir):\n if tf.gfile.Exists(load_dir):\n ckpt = tf.train.get_checkpoint_state(load_dir)\n if ckpt and ckpt.model_checkpoint_path:\n saver.restore(session, ckpt.model_checkpoint_path)\n prev_step = extract_step(ckpt.model_checkpoint_path)\n else:\n tf.gfile.DeleteRecursively(load_dir)\n tf.gfile.MakeDirs(load_dir)\n prev_step = 0\n else:\n tf.gfile.MakeDirs(load_dir)\n prev_step = 0\n return prev_step","def load_checkpoint(path: str, use_cuda: bool = True) -> dict:\n assert os.path.isfile(path), \"Checkpoint %s not found\" % path\n checkpoint = torch.load(path, map_location=\"cuda\" if use_cuda else \"cpu\")\n return checkpoint","def load_checkpoint(self, file):\n \"\"\"Load \"\"\"\n chkpnt = torch.load(file)\n self.load_state_dict(chkpnt['model_state_dict'])","def load_eval(saver, session, load_dir):\n saver.restore(session, load_dir)\n print('model loaded successfully')\n return extract_step(load_dir)","def load_checkpoint(checkpoint_directory,\n session):\n variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n # filter variables if needed.\n print(variables)\n saver_ob = tf.train.Saver(variables, max_to_keep=0)\n os.makedirs(checkpoint_directory, exist_ok=True)\n # verify if we don't have a checkpoint saved directly\n step = 0\n ckpt = tf.train.get_checkpoint_state(checkpoint_directory)\n if ckpt and ckpt.model_checkpoint_path:\n # Restores from checkpoint\n model_checkpoint_path = ckpt.model_checkpoint_path\n saver_ob.restore(session, model_checkpoint_path)\n step = int(model_checkpoint_path.rsplit('-', 1)[1])\n print('Model loaded = ', step)\n return saver_ob, step","def _restore_checkpoint(self, checkpoint_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(checkpoint_path))\n checkpoint = torch.load(checkpoint_path)\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\n \n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\n print('Parameters are inconsistant, adapting model parameters ...')\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\n del pretrained_dict['1']\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\n self.model.load_state_dict(model_dict)\n else:\n print('Parameters are consistant, load state dict directly ...')\n self.model.load_state_dict(checkpoint['state_dict'])\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\n # if self.with_cuda:\n # for state in self.optimizer.state.values():\n # for k, v in state.items():\n # if isinstance(v, torch.Tensor):\n # state[k] = v.cuda(self.device)","def load_state(net, optimizer, scheduler, model_no=0, load_best=False):\n logger.info(\"Initializing model and optimizer states...\")\n base_path = \"./data/\"\n checkpoint_path = os.path.join(base_path,\"test_checkpoint_%d.pth.tar\" % model_no)\n best_path = os.path.join(base_path,\"test_model_best_%d.pth.tar\" % model_no)\n start_epoch, best_pred, checkpoint = 0, 0, None\n if (load_best == True) and os.path.isfile(best_path):\n checkpoint = torch.load(best_path)\n logger.info(\"Loaded best model.\")\n elif os.path.isfile(checkpoint_path):\n checkpoint = torch.load(checkpoint_path)\n logger.info(\"Loaded checkpoint model.\")\n if checkpoint != None:\n start_epoch = checkpoint['epoch']\n best_pred = checkpoint['best_acc']\n net.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n scheduler.load_state_dict(checkpoint['scheduler'])\n logger.info(\"Loaded model and optimizer.\") \n return start_epoch, best_pred","def load_checkpoint(checkpoint_path):\n flat_checkpoint_dict = flatten_checkpoint(\n parse_checkpoint(checkpoint_path), keep_empty_nodes=True)\n return flat_checkpoint_dict","def load_D( self, D_checkpoint):\n checkpoint = torch.load(D_checkpoint)\n self.D.load_state_dict(checkpoint['dnet'])\n self.dis_optim.load_state_dict(checkpoint['gopt'])","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def load_checkpoint(fpath):\n if fpath is None:\n raise ValueError('File path is None')\n if not osp.exists(fpath):\n raise FileNotFoundError('File is not found at \"{}\"'.format(fpath))\n map_location = None if torch.cuda.is_available() else 'cpu'\n try:\n checkpoint = torch.load(fpath, map_location=map_location)\n except UnicodeDecodeError:\n pickle.load = partial(pickle.load, encoding=\"latin1\")\n pickle.Unpickler = partial(pickle.Unpickler, encoding=\"latin1\")\n checkpoint = torch.load(\n fpath, pickle_module=pickle, map_location=map_location\n )\n except Exception:\n print('Unable to load checkpoint from \"{}\"'.format(fpath))\n raise\n return checkpoint","def load_states(self, checkpoint):\n raise NotImplementedError()","def _load_checkpoint(cls, model: DeviceAwareModule, checkpoint_path: Path,\n key_in_state_dict: str, use_gpu: bool) -> int:\n logging.info(f\"Loading checkpoint {checkpoint_path}\")\n checkpoint = ModelAndInfo.read_checkpoint(checkpoint_path, use_gpu)\n\n try:\n state_dict = checkpoint[key_in_state_dict]\n except KeyError:\n logging.error(f\"Key {key_in_state_dict} not found in checkpoint\")\n return False\n\n if isinstance(model, torch.nn.DataParallel):\n result = model.module.load_state_dict(state_dict, strict=False)\n else:\n result = model.load_state_dict(state_dict, strict=False)\n\n if result.missing_keys:\n logging.warning(f\"Missing keys in model checkpoint: {result.missing_keys}\")\n if result.unexpected_keys:\n logging.warning(f\"Unexpected keys in model checkpoint: {result.unexpected_keys}\")\n\n return checkpoint[ModelAndInfo.EPOCH_KEY]","def load(self, sess, step=None):\n if step==None:\n ckpt_path = tf.train.latest_checkpoint(self.model.ckpt_dir)\n else:\n ckpt_path = os.path.join(self.model.ckpt_dir, 'model-'+str(step))\n self.saver.restore(sess, ckpt_path)\n step = tf.train.global_step(sess, self.gstep)\n print('Load model at step {} from check point {}.'.format(step, ckpt_path))","def load_checkpoint(self, session: tf.Session):\n if not _load_checkpoint(session, str(self.info.checkpoint_path)):\n tf_util.init_variables(session)\n return False\n else:\n return True","def load(self, model_path):\n # TODO: include new params based on ConfigEnum\n checkpoint = torch.load(model_path)\n\n self.image_size = checkpoint['image_size']\n self.device = checkpoint['device']\n self.fp16 = checkpoint['fp16']\n self.accumulate_grad_steps = checkpoint['accumulate_grad_steps']\n self.experiment_id = checkpoint['experiment_id']\n self.experiment_tag = checkpoint['experiment_tag']\n self.seed = checkpoint['seed']\n self.train_batch_size = checkpoint['train_batch_size']\n self.valid_batch_size = checkpoint['valid_batch_size']\n self.test_batch_size = checkpoint['test_batch_size']\n self.dataloader_num_workers = checkpoint['dataloader_num_workers']\n self.train_dataloader_shuffle = checkpoint['train_dataloader_shuffle']\n self.optimizer_type = checkpoint['optimizer_type']\n self.optimizer_params = checkpoint['optimizer_params']\n self.scheduler_type = checkpoint['scheduler_type']\n self.scheduler_params = checkpoint['scheduler_params']\n self.step_scheduler_after = checkpoint['step_scheduler_after']\n self.step_scheduler_metric = checkpoint['step_scheduler_metric']\n self.compute_train_loss_after = checkpoint['compute_train_loss_after']\n self.compute_train_metric_after = checkpoint['compute_train_metric_after']\n self.compute_valid_loss_after = checkpoint['compute_valid_loss_after']\n self.compute_valid_metric_after = checkpoint['compute_valid_metric_after']\n self.training_stopping_criteria = checkpoint['training_stopping_criteria']\n self.stopping_criteria_params = checkpoint['stopping_criteria_params']\n self.max_epoch = checkpoint['max_epoch']\n self.train_on_all_data = checkpoint['train_on_all_data']\n self.validate_after = checkpoint['validate_after']\n self.validation_steps = checkpoint['validation_steps']\n self.run_lr_range_test= checkpoint['run_lr_range_test']\n self.sleep_in_epochs = checkpoint['sleep_in_epochs']\n self.sleep_time = checkpoint['sleep_time']\n self.checkpoint_epochs = checkpoint['checkpoint_epochs']\n\n self._best_score = checkpoint['_best_score']\n self._current_score = checkpoint['_current_score']\n self._counter = checkpoint['_counter']\n self.metrics = checkpoint['metrics']\n self.current_epoch = checkpoint['current_epoch']\n self.current_train_batch = checkpoint['current_train_batch']\n self.current_valid_batch = checkpoint['current_valid_batch']\n self.num_train_samples = checkpoint['num_train_samples']\n self.num_train_iterations = checkpoint['num_train_iterations']\n self.checkpoint_snapshot = checkpoint['checkpoint_snapshot'] \n\n # initialize optimizer, scheduler, and gradient scaler\n self.configure_optimizers()\n self.configure_schedulers()\n \n if self.fp16:\n self.scaler = torch.cuda.amp.GradScaler()\n\n if self.model:\n self.model.load_state_dict(checkpoint['state_dict'])\n self.model.to(self.device)\n\n if self.optimizer:\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n if self.scheduler:\n self.scheduler.load_state_dict(checkpoint['scheduler'])\n\n #if self.scaler:\n # self.scaler.load_state_dict(checkpoint['scaler'])","def load_state_dict(self, checkpoint):\n self.net.load_state_dict(checkpoint['Net'])\n self.optimizer.load_state_dict(checkpoint['Optimizer'])\n\n if ADVERSARIAL_FLAG:\n self.adv_net.load_state_dict(checkpoint['AdvNet'])\n self.adv_optimizer.load_state_dict(checkpoint['AdvOptimizer'])\n\n self.history = checkpoint['History']\n self.stats = checkpoint['Stats']\n\n # The following loops are used to fix a bug that was\n # discussed here: https://github.com/pytorch/pytorch/issues/2830\n # (it is supposed to be fixed in recent PyTorch version)\n for state in self.optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = v.to(self.net.device)\n if ADVERSARIAL_FLAG:\n for adv_state in self.adv_optimizer.state.values():\n for k, v in adv_state.items():\n if isinstance(v, torch.Tensor):\n adv_state[k] = v.to(self.adv_net.device)","def load(self, path):\n\n filename = self.__path(path, prefix=None)\n chkpt = th.load(filename, map_location=\"cpu\") # TODO: check behavior\n\n if self.model is not None and chkpt[\"model\"] is not None:\n log.debug(\"Loading model state dict\")\n self.model.load_state_dict(chkpt[\"model\"])\n\n if \"optimizers\" in chkpt.keys():\n if self.optimizers is not None and chkpt[\"optimizers\"] is not None:\n try:\n for opt, state in zip(self.optimizers,\n chkpt[\"optimizers\"]):\n log.debug(\"Loading optimizers state dict for %s\", opt)\n opt.load_state_dict(state)\n except:\n # We do not raise an error here, e.g. in case the user simply\n # changes optimizer\n log.warning(\"Could not load optimizer state dicts, \"\n \"starting from scratch\")\n\n if \"schedulers\" in chkpt.keys():\n if self.schedulers is not None and chkpt[\"schedulers\"] is not None:\n try:\n for s, state in zip(self.schedulers,\n chkpt[\"schedulers\"]):\n log.debug(\"Loading scheduler state dict for %s\", s)\n s.load_state_dict(state)\n except:\n log.warning(\"Could not load scheduler state dicts, \"\n \"starting from scratch\")\n\n log.debug(\"Loaded checkpoint \\\"{}\\\"\".format(filename))\n return tuple(chkpt[k] for k in [\"extras\", \"meta\"])","def load_actor(self, checkpoint):\n \n model = torch.load(checkpoint)\n self.actor_local.load_state_dict(model)","def load_checkpoint(self, checkpoint_filepath=None, verbose=True):\n if checkpoint_filepath:\n print('loading', checkpoint_filepath, flush=True)\n optimistic_restore(self._session, checkpoint_filepath, verbose=verbose)\n return True\n else:\n checkpoints = retrieve_all_checkpoints(self._checkpoints_path) + retrieve_all_checkpoints(self._recovery_checkpoints_path)\n\n if checkpoints:\n last_checkpoint = sorted(checkpoints)[-1][1]\n print('loading', last_checkpoint, flush=True)\n optimistic_restore(self._session, last_checkpoint, verbose=verbose)\n return True\n else:\n print('nothing to restore. no checkpoint found.', flush=True)\n return False","def load_weights(self, checkpoint_path, sess=None):\n\n if sess is None:\n sess = tf.get_default_session()\n assert sess is not None\n\n saver = tf.train.Saver(self.variables_to_restore)\n saver.restore(sess, checkpoint_path)","def load_weights(self, checkpoint_path, sess=None):\n\n if sess is None:\n sess = tf.get_default_session()\n assert sess is not None\n\n saver = tf.train.Saver(self.variables_to_restore)\n saver.restore(sess, checkpoint_path)","def load_weights(self, checkpoint_path, sess=None):\n\n if sess is None:\n sess = tf.get_default_session()\n assert sess is not None\n\n saver = tf.train.Saver(self.variables_to_restore)\n saver.restore(sess, checkpoint_path)","def get_checkpoint(model, checkpoint='-1'):\n if not os.path.isfile(os.path.join(model, \"checkpoint\")):\n sys.exit(\"[ERROR] Cannot find checkpoint in %s.\" % model)\n ckpt = tf.train.get_checkpoint_state(model)\n\n model_checkpoint_path = ckpt.model_checkpoint_path\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\n\n if not ckpt or not model_checkpoint_path:\n sys.exit(\"[ERROR] Cannot read checkpoint %s.\" % os.path.join(model, \"checkpoint\"))\n\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\n steps = sorted(steps)\n if checkpoint == \"last\":\n tf.logging.info(\"Load the last saved model.\")\n checkpoint = steps[-1]\n else:\n checkpoint = int(checkpoint)\n if checkpoint == -1:\n tf.logging.info(\"Load the best model according to valid_loss\")\n min_epoch = -1\n min_loss = 1e10\n with open(os.path.join(model, \"valid_loss\")) as f:\n for line in f.readlines():\n epoch, loss, eer = line.split(\" \")\n epoch = int(epoch)\n loss = float(loss)\n if loss < min_loss:\n min_loss = loss\n min_epoch = epoch\n # Add 1 to min_epoch since epoch is 0-based\n config_json = os.path.join(model, \"config.json\")\n params = Params(config_json)\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\n tf.logging.info(\"The checkpoint is %d\" % checkpoint)\n assert checkpoint in steps, \"The checkpoint %d not in the model directory\" % checkpoint\n\n model_checkpoint_path = model_checkpoint_path.rsplit(\"-\", 1)[0] + \"-\" + str(checkpoint)\n model_checkpoint_path = os.path.join(model, os.path.basename(model_checkpoint_path))\n\n with open(os.path.join(model, \"checkpoint\"), \"w\") as f:\n f.write(\"model_checkpoint_path: \\\"%s\\\"\\n\" % model_checkpoint_path)\n for checkpoint in all_model_checkpoint_paths:\n checkpoint_new = os.path.join(model, os.path.basename(checkpoint))\n f.write(\"all_model_checkpoint_paths: \\\"%s\\\"\\n\" % checkpoint_new)\n return model_checkpoint_path"],"string":"[\n \"def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\\n print(\\\"Load checkpoint from: {}\\\".format(path))\\n state_dict, optimizer_state = _load(path)\\n\\n model.load_dict(state_dict)\\n if not reset_optimizer and optimizer is not None:\\n if optimizer_state is not None:\\n print(\\\"[loading] Load optimizer state from {}\\\".format(path))\\n optimizer.load(optimizer_state)\\n\\n return model\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n model_state_dict, optimizer_state_dict = torch.load(checkpoint)\\n model.load_state_dict(model_state_dict)\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(optimizer_state_dict)\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint)\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(f\\\"Checkpoint '{checkpoint_path}' does not exist\\\")\\n\\n state = torch.load(checkpoint_path)\\n try:\\n model.load_state_dict(state['model_state_dict'])\\n except BaseException as e:\\n print('Failed to do something: ' + str(e))\\n\\n if optimizer is not None:\\n try:\\n optimizer.load_state_dict(state['optimizer_state_dict'])\\n except Exception as e:\\n print(e)\\n\\n return state\",\n \"def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\\n self.model.load_state_dict(checkpoint[\\\"model_state_dict\\\"])\\n self.optimizer.load_state_dict(checkpoint[\\\"optimizer_state_dict\\\"])\\n return self\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None,\\n model_key='model_state_dict', optimizer_key='optimizer_state_dict'):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(f\\\"Checkpoint '{checkpoint_path}' does not exist\\\")\\n\\n state = torch.load(checkpoint_path, map_location='cpu')\\n model.load_state_dict(state[model_key])\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(state[optimizer_key])\\n\\n return state\",\n \"def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\\n print(\\\"Loading checkpoint: {}\\\".format(checkpoint_path))\\n state = torch.load(checkpoint_path)\\n self.model.load_state_dict(state['state_dict'])\\n self.optimizer.load_state_dict(state['optim_dict'])\\n\\n if continue_from_epoch:\\n self.epoch = state['epoch']\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(\\\"Checkpoint '{}' does not exist\\\".format(checkpoint_path))\\n\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else 'cpu')\\n state = torch.load(checkpoint_path, map_location=\\\"cuda:0\\\")\\n model.load_state_dict(state['model_state_dict'])\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(state['optimizer_state_dict'])\\n\\n return state\",\n \"def _load(checkpoint_path):\\n state_dict, optimizer_state = dg.load_persistables(dirname=checkpoint_path)\\n return state_dict, optimizer_state\",\n \"def load_checkpoint(args, trainer, epoch_itr):\\n os.makedirs(os.path.join(args.save_dir, 'checkpoints'), exist_ok=True)\\n checkpoint_path = os.path.join(args.save_dir, 'checkpoints', args.restore_file)\\n if os.path.isfile(checkpoint_path):\\n extra_state = trainer.load_checkpoint(checkpoint_path)\\n if extra_state is not None:\\n # replay train iterator to match checkpoint\\n epoch_itr.load_state_dict(extra_state['train_iterator'])\\n\\n print('| loaded checkpoint {} (epoch {} @ {} updates)'.format(\\n checkpoint_path, epoch_itr.epoch, trainer.get_num_updates()))\\n\\n trainer.lr_step(epoch_itr.epoch)\\n trainer.lr_step_update(trainer.get_num_updates())\\n if 'best' in extra_state:\\n save_checkpoint.best = extra_state['best']\",\n \"def load_checkpoint(tag, params, model):\\r\\n file_name = os.path.join(\\\"saved_models\\\", params.path, tag + \\\".pt\\\")\\r\\n logger.info(\\\"Load checkpoint from %s\\\" % file_name)\\r\\n if os.path.exists(file_name):\\r\\n checkpoint = torch.load(file_name, map_location='cpu')\\r\\n params.training_id = checkpoint['training_id']\\r\\n logger.info(checkpoint['training_id'])\\r\\n model.global_step = checkpoint['global_step']\\r\\n model.load_state_dict(checkpoint['model'])\\r\\n for i, optimizer in enumerate(model.optimizers):\\r\\n optimizer.load_state_dict(checkpoint['optimizers'][i])\\r\\n else:\\r\\n raise Exception(\\\"Checkpoint not found.\\\")\",\n \"def load_ckp(checkpoint_fpath, model, optimizer, device):\\n\\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\\n model.load_state_dict(checkpoint['state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n valid_acc = checkpoint['valid_acc'] \\n return model, optimizer, checkpoint['epoch'], valid_acc\",\n \"def load(loadname, checkpoint=None):\\n ckpt_dir = \\\"./models/tf_ckpt_\\\" + loadname + \\\"/\\\"\\n if checkpoint is not None:\\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\\n status.assert_consumed()\\n print(\\\"Loaded checkpoint\\\")\\n else:\\n print(\\\"Not Loading any checkpoint\\\")\\n print(\\\"Starting training from initial configuration\\\")\",\n \"def load_checkpoint(self):\\n checkpoin_path = self.get_checkpoint_path()\\n _logger.info('Load checkpoint ignored by tuner, checkpoint path: %s', checkpoin_path)\",\n \"def load_checkpoint(self, session, model_dir):\\n assert self.params.cp_load == True, (\\\"cp_load must be set to true to load a checkpoint\\\")\\n self.loader.restore(session, model_dir)\",\n \"def load_checkpoint(self, checkpoint_path=None):\\n if checkpoint_path is None:\\n checkpoint_path = self.get_latest_path()\\n\\n if os.path.isfile(checkpoint_path):\\n key = 'cuda' if torch.cuda.is_available() else 'cpu'\\n checkpoint = torch.load(checkpoint_path, map_location=key)\\n self.network.load_state_dict(checkpoint['network'])\\n self.network_target.load_state_dict(checkpoint['network_target'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n print('checkpoint loaded at {}'.format(checkpoint_path))\\n else:\\n raise OSError(\\\"Checkpoint file not found.\\\")\",\n \"def load_pretrained(model, fname, optimizer=None):\\n if os.path.isfile(fname):\\n print(\\\"=> loading checkpoint '{}'\\\".format(fname))\\n checkpoint = torch.load(fname)\\n model.load_state_dict(checkpoint['state_dict'])\\n if optimizer is not None:\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n return model, optimizer, checkpoint['epoch']\\n else:\\n return model\\n else:\\n raise Exception(\\\"=> no checkpoint found at '{}'\\\".format(fname))\",\n \"def load_checkpoint(ckpt_path):\\n checkpoint = None\\n if ckpt_path:\\n logger.info(\\\"Loading checkpoint from %s\\\" % ckpt_path)\\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\\\"cpu\\\"))\\n\\n if \\\"model\\\" in checkpoint.keys():\\n # This preserves backward-compat for models using customed layernorm\\n def fix_key(s):\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.b_2\\\", r\\\"\\\\1.layer_norm\\\\2.bias\\\", s\\n )\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.a_2\\\", r\\\"\\\\1.layer_norm\\\\2.weight\\\", s\\n )\\n return s\\n\\n checkpoint[\\\"model\\\"] = {\\n fix_key(k): v for k, v in checkpoint[\\\"model\\\"].items()\\n }\\n # Force add_ffnbias to True if bias found in model w_1 keys\\n for key in checkpoint[\\\"model\\\"].keys():\\n if \\\"w_1.bias\\\" in key:\\n checkpoint[\\\"opt\\\"].add_ffnbias = True\\n\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"num_kv\\\"):\\n checkpoint[\\\"opt\\\"].num_kv = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"add_ffnbias\\\"):\\n checkpoint[\\\"opt\\\"].add_ffnbias = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_residual\\\"):\\n checkpoint[\\\"opt\\\"].parallel_residual = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"shared_layer_norm\\\"):\\n checkpoint[\\\"opt\\\"].shared_layer_norm = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"use_ckpting\\\"):\\n checkpoint[\\\"opt\\\"].use_ckpting = []\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"relative_positions_buckets\\\"):\\n checkpoint[\\\"opt\\\"].relative_positions_buckets = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_mode\\\"):\\n checkpoint[\\\"opt\\\"].parallel_mode = \\\"data_parallel\\\"\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"norm_eps\\\"):\\n checkpoint[\\\"opt\\\"].norm_eps = 1e-6\\n\\n # fix v2 compatibility\\n if \\\"generator\\\" in checkpoint.keys() and checkpoint[\\\"generator\\\"]:\\n if \\\"0.weight\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"weight\\\"] = checkpoint[\\\"generator\\\"].pop(\\n \\\"0.weight\\\"\\n )\\n if \\\"0.bias\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"bias\\\"] = checkpoint[\\\"generator\\\"].pop(\\\"0.bias\\\")\\n # end of patch for backward compatibility\\n\\n return checkpoint\",\n \"def load_from_checkpoint(self, path):\\n print(f'# loading trainer state from {path}')\\n checkpoint = torch.load(path)\\n self.load(checkpoint)\",\n \"def load(self, path):\\n checkpoint = torch.load(path)\\n self.load_state_dict(checkpoint['model_state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\",\n \"def load(self, path):\\n checkpoint = torch.load(path)\\n self.load_state_dict(checkpoint['model_state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\",\n \"def load_model(path, model, optimizer):\\n print(\\\"LOADING MODEL...\\\")\\n ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)\\n status = ckpt.restore(tf.train.latest_checkpoint(path))\\n ckpt_manager = tf.train.CheckpointManager(\\n checkpoint=ckpt, \\n directory=FLAGS.model_dir, \\n max_to_keep=3 \\n )\\n return model, optimizer, ckpt, ckpt_manager\",\n \"def load_checkpoint(self, filename, load_optim=True):\\n extra_state, optim_history, last_optim_state = \\\\\\n utils.load_model_state(filename, self.get_model())\\n\\n if last_optim_state is not None:\\n # rebuild optimizer after loading model, since params may have changed\\n #self.optimizer = optim.build_optimizer(self.args, self.model.parameters())\\n self.lr_scheduler = lr_scheduler.build_lr_scheduler(self.args, self.optimizer)\\n\\n if load_optim:\\n self._optim_history = optim_history\\n # only reload optimizer and lr_scheduler if they match\\n last_optim = self._optim_history[-1]\\n if last_optim['criterion_name'] == self.criterion.__class__.__name__:\\n self.lr_scheduler.load_state_dict(last_optim['lr_scheduler_state'])\\n if last_optim['optimizer_name'] == self.optimizer.__class__.__name__:\\n self.optimizer.load_state_dict(last_optim_state)\\n\\n self._num_updates = last_optim['num_updates']\\n\\n return extra_state\",\n \"def load_model_from_checkpoint(self, path: str):\\n ckpt = torch.load(path, map_location='cpu')\\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\\n self.net_q.head.load_state_dict(ckpt['head'])\\n self.net_ps.load_state_dict(ckpt['net_ps'])\\n self.net_k.load_state_dict(ckpt['net_k'])\\n self.queue.load_state_dict(ckpt['queue'])\\n self.optimizer.load_state_dict(ckpt['optimizer'])\\n if 'scheduler' in ckpt:\\n self.scheduler.load_stae_dict(ckpt['scheduler'])\\n self.move_optimizer_states(self.optimizer, self.local_rank)\",\n \"def load_checkpoint(self, model, optimizers):\\n self.epoch = get_last_epoch(self.log_path)\\n\\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\\n model.load_state_dict(model_state_dict)\\n\\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\\n for opt_ind in range(len(optimizers)):\\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\\n\\n schedulers = load_sched(optimizers, self.epoch)\\n\\n return model, optimizers, schedulers\",\n \"def load_checkpoint(self, label):\\n model_dir = os.path.join(\\n config.results_dir, config.experiment_name, 'checkpoints')\\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\\n\\n print(\\\"Loading model from {}\\\".format(model_file))\\n model_dict = torch.load(model_file)\\n\\n self.use_cuda = model_dict['use_cuda']\\n if self.use_cuda:\\n self.net.cuda()\\n\\n self.net.load_state_dict(model_dict['net_state_dict'])\",\n \"def LoadProgramState(self, restored_checkpoint_path=None, sess=None):\\n pass\",\n \"def _resume_checkpoint(self, resume_path, model, optimizer):\\n if not resume_path:\\n return model, optimizer\\n\\n self.logger.info(f'Loading checkpoint: {resume_path}')\\n checkpoint = torch.load(resume_path)\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n # load optimizer state from checkpoint only when optimizer type is not changed.\\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\\n self.logger.warning(\\\"Warning: Optimizer type given in config file is different from \\\"\\n \\\"that of checkpoint. Optimizer parameters not being resumed.\\\")\\n else:\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n self.logger.info(f'Checkpoint \\\"{resume_path}\\\" loaded')\\n return model, optimizer\",\n \"def load_model(self, checkpoint):\\n print(f'Load parameters from {checkpoint}')\\n epoch = re.match(r\\\"[0-9]*\\\", os.path.basename(checkpoint)).group(0)\\n self.epoch_i = int(epoch)\\n self.model.load_state_dict(torch.load(checkpoint))\",\n \"def load_checkpoint(self):\\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\\n try:\\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\\n ckpt = torch.load(self.params.resume_from)\\n self.epoch = ckpt['epoch']\\n try:\\n self.train_loss = ckpt['train_loss']\\n self.val_loss = ckpt['val_loss']\\n except:\\n self.train_loss = []\\n self.val_loss = []\\n self.network.load_state_dict(ckpt['state_dict'])\\n self.opt.load_state_dict(ckpt['optimizer'])\\n LOG('Checkpoint Loaded!')\\n LOG('Current Epoch: %d' % self.epoch)\\n self.ckpt_flag = True\\n except:\\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\\n else:\\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')\",\n \"def load_ckpt(self, name=None):\\r\\n name = name if name == 'latest' else \\\"ckpt_epoch{}\\\".format(name)\\r\\n load_path = os.path.join(self.model_dir, \\\"{}.pth\\\".format(name))\\r\\n if not os.path.exists(load_path):\\r\\n raise ValueError(\\\"Checkpoint {} not exists.\\\".format(load_path))\\r\\n\\r\\n checkpoint = torch.load(load_path)\\r\\n print(\\\"Checkpoint loaded from {}\\\".format(load_path))\\r\\n if isinstance(self.net, nn.DataParallel):\\r\\n self.net.module.load_state_dict(checkpoint['model_state_dict'])\\r\\n else:\\r\\n self.net.load_state_dict(checkpoint['model_state_dict'])\\r\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\r\\n self.scheduler.load_state_dict(checkpoint['scheduler_state_dict'])\\r\\n self.clock.restore_checkpoint(checkpoint['clock'])\",\n \"def load_checkpoint(self, checkpoint_path: str, *args, **kwargs) -> Dict:\\n return torch.load(checkpoint_path, *args, **kwargs)\",\n \"def load_checkpoint(self, checkpoint_path: str, *args, **kwargs) -> Dict:\\n return torch.load(checkpoint_path, *args, **kwargs)\",\n \"def load_checkpoint_train(cpdir, model, optimizer):\\n start_epoch = 0\\n start_global_step = 0\\n if cpdir is not None:\\n start_global_step, start_epoch = load_checkpoint(\\n cpdir, model, optimizer)\\n start_global_step += 1\\n start_epoch += 1\\n return start_global_step, start_epoch\",\n \"def load_checkpoint(cfg, args):\\n checkpoint_iteration = args.checkpoint\\n bucket = connect_to_bucket(args.bucket)\\n # load actual checkpoint\\n if not os.path.isdir(cfg.OUTPUT_DIR):\\n os.mkdir(cfg.OUTPUT_DIR)\\n blob = bucket.blob(cfg.OUTPUT_DIR + \\\"/model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n blob.download_to_filename(cfg.OUTPUT_DIR + \\\"/model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n if args.resume:\\n # also write last checkpoint file for when --resume statement, model gets checkpoint name from this file\\n with open(cfg.OUTPUT_DIR + \\\"/last_checkpoint\\\", \\\"w\\\") as file:\\n file.write(\\\"model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n # return statement not clean, but useful for inference code\\n return checkpoint_iteration, bucket\",\n \"def load_from_path(self, checkpoint_dir):\\n\\n vars = self.save_var_names\\n saver = tf.train.Saver(vars)\\n\\n def load_aux(ckpt_path):\\n \\\"\\\"\\\"Helper function to not repeat the same code in the following lines.\\\"\\\"\\\"\\n\\n ckpt_name = os.path.basename(ckpt_path)\\n saver.restore(self.sess, ckpt_path)\\n counter = int(next(re.finditer(\\\"(\\\\d+)(?!.*\\\\d)\\\", ckpt_name)).group(0))\\n self.counter = counter\\n print(\\\" [*] Loaded {}\\\".format(ckpt_name))\\n return True, counter\\n\\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\\n try:\\n if ckpt and ckpt.model_checkpoint_path:\\n ckpt_name = os.path.basename(ckpt.model_checkpoint_path)\\n return load_aux(os.path.join(checkpoint_dir, ckpt_name))\\n else:\\n print(\\n \\\" [!] Failed to find a checkpoint within directory {}\\\".format(\\n FLAGS.ckpt_path))\\n return False, 0\\n except:\\n print(\\\" [!] Failed to find a checkpoint, Exception!\\\")\\n return False, 0\",\n \"def load(cls, path):\\n print(f'load checkpoint from {path}')\\n if torch.cuda.is_available():\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\\n else:\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\\n \\n # model.flatten_parameters() # make RNN parameters contiguous\\n optimizer = resume_checkpoint['optimizer']\\n return Checkpoint(\\n model=model, \\n optimizer=optimizer,\\n epoch=resume_checkpoint['epoch'],\\n path=path\\n )\",\n \"def load_checkpoint(self, checkpoint: str, **kwargs) -> None:\\n with open(checkpoint, \\\"rb\\\") as f:\\n state = SafePickle.load(f)\\n\\n state_id = ray.put(state)\\n ray.get([worker.set_state.remote(state_id, **kwargs) for worker in self.remote_workers])\",\n \"def opt_from_checkpoint(\\n checkpoint_path: str,\\n config_path: Optional[str] = None,\\n extra_bindings=tuple([])\\n) -> Optimizer:\\n\\n if config_path is None:\\n config_path = \\\"/\\\".join(checkpoint_path.split(\\\"/\\\")[:-1]) + \\\"/config.gin\\\"\\n\\n logging.info(\\\"Restoring configs from: %s\\\", config_path)\\n with gin.unlock_config():\\n scope = f\\\"opt_from_checkpoint__{str(uuid.uuid4()).replace('-', '_')}\\\"\\n with gin.config_scope(None):\\n with gin.config_scope(scope):\\n if config_path:\\n with file_open(config_path, \\\"rb\\\") as f:\\n content = bytes(f.read()).decode(\\\"utf-8\\\")\\n\\n # gin writes out multi line sometimes, undo this.\\n content = content.replace(\\\"\\\\\\\\\\\\n\\\", \\\"\\\")\\n\\n def maybe_add_scope(c):\\n # filter out train as this overlaps with outer_training.\\n if c.startswith(\\\"#\\\"):\\n return None\\n if \\\"=\\\" in c:\\n return scope + \\\"/\\\" + c\\n return c\\n\\n bindings = [maybe_add_scope(c) for c in content.split(\\\"\\\\n\\\")]\\n bindings = [b for b in bindings if b]\\n bindings = bindings + [maybe_add_scope(c) for c in extra_bindings]\\n\\n logging.info(\\\"Parsing bindings\\\")\\n for b in bindings:\\n logging.info(b)\\n print(b)\\n gin.parse_config(bindings, skip_unknown=True)\\n\\n configurable = gin.query_parameter(f\\\"{scope}/run_train.lopt\\\")\\n if isinstance(configurable, gin.config._UnknownConfigurableReference): # pylint: disable=protected-access\\n raise ValueError(\\\"Gin couldn't find the learned optimizer in current\\\"\\n \\\" imports. Did you forget to import the module?\\\")\\n\\n # with summary.summary_scope(\\\"opt_from_checkpoint\\\"):\\n lopt = configurable.configurable.wrapped()\\n theta = lopt.init(jax.random.PRNGKey(0))\\n logging.info(f\\\"Restoring checkpoint {checkpoint_path}\\\") # pylint: disable=logging-fstring-interpolation\\n ckpt = ParameterCheckpoint(theta, \\\"\\\", 0)\\n ckpt = load_state(checkpoint_path, ckpt)\\n opt = lopt.opt_fn(ckpt.params)\\n return opt\\n # wrapped = _GinScopeClass(opt, scope)\\n # For now, just add the lopt to the returned class.\\n # TODO(lmetz) change this api to return a more structured class?\\n # wrapped.lopt = lopt\\n # return wrapped # type: ignore\",\n \"def load_checkpoint(self, path: str = '', train: bool = True) -> int:\\n\\n if not path:\\n dir_ = os.path.dirname(os.path.realpath('__file__'))\\n path = os.path.join(dir_, 'model.pt')\\n\\n try:\\n ckpt = torch.load(path)\\n except FileNotFoundError:\\n return 0\\n else:\\n print('Loaded model at epoch: ', end='')\\n\\n self.load_state_dict(ckpt['model_state_dict'])\\n self.actor_optimizer.load_state_dict(ckpt['ac_optim_dict'])\\n self.critic_optimizer.load_state_dict(ckpt['critic_optim_dict'])\\n epoch = ckpt['epoch']\\n\\n print(epoch)\\n\\n if not train:\\n self.eval()\\n else:\\n self.train()\\n\\n return epoch\",\n \"def try_create_optimizer_and_load_from_checkpoint(self) -> bool:\\n self.create_optimizer()\\n if self.checkpoint_path:\\n return self.try_load_checkpoint_for_optimizer()\\n return True\",\n \"def reload_checkpoint(self):\\n checkpoint_path = os.path.join(self.params.dump_path, 'checkpoint.pth')\\n if not os.path.isfile(checkpoint_path):\\n if self.params.reload_checkpoint == '':\\n return\\n else:\\n checkpoint_path = self.params.reload_checkpoint\\n assert os.path.isfile(checkpoint_path)\\n logger.warning(\\\"Reloading checkpoint from %s ...\\\" % checkpoint_path)\\n data = torch.load(checkpoint_path, map_location='cpu')\\n\\n # reload model parameters\\n for name in self.MODEL_NAMES:\\n getattr(self, name).load_state_dict(data[name])\\n\\n # reload optimizers\\n for name in self.optimizers.keys():\\n if False: # AMP checkpoint reloading is buggy, we cannot do that - TODO: fix - https://github.com/NVIDIA/apex/issues/250\\n logger.warning(\\\"Reloading checkpoint optimizer %s ...\\\" % name)\\n else: # instead, we only reload current iterations / learning rates\\n logger.warning(\\\"Not reloading checkpoint optimizer %s.\\\" % name)\\n for group_id, param_group in enumerate(self.optimizers[name].param_groups):\\n if 'num_updates' not in param_group:\\n logger.warning(\\\"No 'num_updates' for optimizer %s.\\\" % name)\\n continue\\n logger.warning(\\\"Reloading 'num_updates' and 'lr' for optimizer %s.\\\" % name)\\n param_group['num_updates'] = data['%s_optimizer' % name]['param_groups'][group_id]['num_updates']\\n param_group['lr'] = self.optimizers[name].get_lr_for_step(param_group['num_updates'])\\n\\n # reload main metrics\\n self.epoch = data['epoch'] + 1\\n self.n_total_iter = data['n_total_iter']\\n self.best_metrics = data['best_metrics']\\n self.best_stopping_criterion = data['best_stopping_criterion']\\n logger.warning(\\\"Checkpoint reloaded. Resuming at epoch %i / iteration %i ...\\\" % (self.epoch, self.n_total_iter))\",\n \"def load_ckpt(saver, sess, ckpt_dir=\\\"train\\\"):\\n while True:\\n try:\\n latest_filename = \\\"checkpoint_best\\\" if ckpt_dir==\\\"eval\\\" else None\\n ckpt_dir = os.path.join(FLAGS.log_root, ckpt_dir)\\n ckpt_state = tf.train.get_checkpoint_state(ckpt_dir, latest_filename=latest_filename)\\n tf.logging.info('Loading checkpoint %s', ckpt_state.model_checkpoint_path)\\n saver.restore(sess, ckpt_state.model_checkpoint_path)\\n return ckpt_state.model_checkpoint_path\\n except:\\n tf.logging.info(\\\"Failed to load checkpoint from %s. Sleeping for %i secs...\\\", ckpt_dir, 10)\\n time.sleep(10)\",\n \"def load_ckpt(saver, sess, ckpt_dir=\\\"train\\\"):\\n while True:\\n try:\\n latest_filename = \\\"checkpoint_best\\\" if ckpt_dir == \\\"eval\\\" else None\\n ckpt_dir = os.path.join(FLAGS.log_root, ckpt_dir)\\n ckpt_state = tf.train.get_checkpoint_state(ckpt_dir, latest_filename=latest_filename)\\n tf.logging.info('Loading checkpoint %s', ckpt_state.model_checkpoint_path)\\n saver.restore(sess, ckpt_state.model_checkpoint_path)\\n return ckpt_state.model_checkpoint_path\\n except:\\n tf.logging.info(\\\"Failed to load checkpoint from %s. Sleeping for %i secs...\\\", ckpt_dir, 10)\\n time.sleep(10)\",\n \"def load_checkpoint(model, save_path):\\n model.load_state_dict(torch.load(save_path))\",\n \"def load(self, checkpoint_dir):\\n print(\\\"\\\\nReading Checkpoints.....\\\\n\\\\n\\\")\\n model_dir = \\\"%s\\\" % (\\\"cnn\\\") # give the model name by label_size\\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir)\\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\\n \\n # Check the checkpoint is exist\\n if ckpt and ckpt.model_checkpoint_path:\\n ckpt_path = str(ckpt.model_checkpoint_path) # convert the unicode to string\\n self.saver.restore(self.sess, os.path.join(os.getcwd(), ckpt_path))\\n print(\\\"\\\\n Checkpoint Loading Success! %s\\\\n\\\\n\\\"% ckpt_path)\\n else:\\n print(\\\"\\\\n! Checkpoint Loading Failed \\\\n\\\\n\\\")\",\n \"def load_model(agent, optimizer, model_file):\\n checkpoint = torch.load(model_file)\\n episode = checkpoint['epoch']\\n agent.load_state_dict(checkpoint['model_state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\n return episode\",\n \"def load_from_checkpoint(results_dir, load_fn, args):\\n ckpt_dir = os.path.join(results_dir, \\\"tb\\\", \\\"version_0\\\", \\\"checkpoints\\\")\\n files = os.listdir(ckpt_dir)\\n assert len(files) > 0, \\\"Checkpoint directory is empty\\\"\\n ckpt_path = os.path.join(ckpt_dir, files[-1])\\n model = load_fn(checkpoint_path=ckpt_path, args=args)\\n return model\",\n \"def load(self):\\r\\n checkpoint = torch.load(self.checkpoint_path,\\r\\n map_location=self.device)\\r\\n self.load_state_dict(checkpoint)\\r\\n del checkpoint\",\n \"def load(self, checkpoint_dir=None):\\n\\n if checkpoint_dir is None:\\n checkpoint_dir = FLAGS.checkpoint_dir\\n\\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\\n\\n return self.load_from_path(checkpoint_dir)\",\n \"def load(self):\\n checkpoint = torch.load(self.checkpoint_path,\\n map_location=self.net.device)\\n self.load_state_dict(checkpoint)\\n del checkpoint\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.monitor_best = checkpoint['monitor_best']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n if self.with_cuda:\\n for state in self.optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = v.cuda(torch.device('cuda'))\\n self.train_logger = checkpoint['logger']\\n #self.config = checkpoint['config']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def load_training_checkpoint(args, model, PATH, ckpt_id):\\r\\n logger = args.logger\\r\\n _, checkpoint_state_dict = model.network.load_checkpoint(PATH, ckpt_id)\\r\\n epoch = checkpoint_state_dict['epoch']\\r\\n last_global_step = checkpoint_state_dict['last_global_step']\\r\\n last_global_data_samples = checkpoint_state_dict[\\r\\n 'last_global_data_samples']\\r\\n del checkpoint_state_dict\\r\\n return (epoch, last_global_step, last_global_data_samples)\",\n \"def _resume_checkpoint(self, resume_path):\\n resume_path = str(resume_path)\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n\\n # load architecture params from checkpoint.\\n if checkpoint['config']['model'] != self.config['model']:\\n self.logger.warning(\\\"Warning: Architecture configuration given in config file is different from that of \\\"\\n \\\"checkpoint. This may yield an exception while state_dict is being loaded.\\\")\\n self.model.load_state_dict(checkpoint['state_dict'])\\n\\n # load optimizer state from checkpoint only when optimizer type is not changed.\\n if checkpoint['config']['trainer']['optimizer']['type'] != self.config['trainer']['optimizer']['type']:\\n self.logger.warning(\\\"Warning: Optimizer type given in config file is different from that of checkpoint. \\\"\\n \\\"Optimizer parameters not being resumed.\\\")\\n else:\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n self.logger.info(\\\"Checkpoint loaded. Resume from epoch {}\\\".format(self.start_epoch))\",\n \"def load_model(model, checkpoint_path: str): \\r\\n checkpoint = torch.load(checkpoint_path)\\r\\n model.load_state_dict(checkpoint['model'])\\r\\n epoch = checkpoint['epoch']\\r\\n print('Loaded model from {}, epoch {}'.format(checkpoint_path, epoch))\",\n \"def restore(self, checkpoint_path):\\n start_time = time.time()\\n latest_checkpoint = train_util.get_latest_chekpoint(checkpoint_path)\\n if latest_checkpoint is not None:\\n checkpoint = tf.train.Checkpoint(model=self)\\n checkpoint.restore(latest_checkpoint).expect_partial()\\n logging.info('Loaded checkpoint %s', latest_checkpoint)\\n logging.info('Loading model took %.1f seconds', time.time() - start_time)\\n else:\\n logging.info('Could not find checkpoint to load at %s, skipping.',\\n checkpoint_path)\",\n \"def load_model(self, ckpt_fn):\\n checkpoint = torch.load(ckpt_fn)\\n self.net_.load_state_dict(checkpoint[\\\"model\\\"])\\n self.optimizer_.load_state_dict(checkpoint[\\\"optimizer\\\"])\\n self.epoch_ = checkpoint[\\\"epoch\\\"]\\n self.global_step_ = checkpoint[\\\"global_step\\\"]\\n self.model_samples_ = deque(checkpoint[\\\"model_samples\\\"])\\n self.sampler.load_state_dict(checkpoint[\\\"sampler_state\\\"])\\n self.ais_loss.load_state_dict(checkpoint[\\\"ais_state\\\"])\\n self.replay_prob = checkpoint[\\\"replay_prob\\\"]\\n self.max_replay = checkpoint[\\\"max_replay\\\"]\",\n \"def load_checkpoint(checkpoint_dir, epoch, iteration):\\n path = opj(checkpoint_dir, str(epoch) + '.' + str(iteration) + '.ckpt')\\n if not os.path.isfile(path):\\n raise Exception(\\\"Checkpoint in epoch %d doesn't exist :sob:\\\" % epoch)\\n\\n checkpoint = torch.load(path)\\n start_epoch = checkpoint['epoch']\\n state_dict = checkpoint['state_dict']\\n start_iteration = checkpoint['iteration']\\n\\n assert iteration == start_iteration\\n return start_epoch, start_iteration, state_dict\",\n \"def load_model (checkpoint_path, model, opt_fn=None, loss_fn=None, epoch=None):\\n\\n if not os.path.exists(checkpoint_path):\\n raise Exception (\\\"The {} does not exist!\\\".format(checkpoint_path))\\n\\n ckpt = torch.load(checkpoint_path)\\n model.load_state_dict(ckpt['model_state_dict'])\\n\\n if opt_fn is not None and loss_fn is not None:\\n opt_fn.load_state_dict(ckpt['optimizer_state_dict'])\\n epoch = ckpt['epoch']\\n loss_fn = ckpt['loss']\\n return model, opt_fn, loss_fn, epoch\\n else:\\n return model\",\n \"def load_checkpoint(path):\\n\\n # Get the model name\\n model_name = path.split('-')[0]\\n assert (model_name in ['vgg16', 'resnet50'\\n ]), \\\"Path must have the correct model name\\\"\\n\\n # Load in checkpoint\\n checkpoint = torch.load(path)\\n\\n if model_name == 'vgg16':\\n model = models.vgg16(pretrained=True)\\n # Make sure to set parameters as not trainable\\n for param in model.parameters():\\n param.requires_grad = False\\n model.classifier = checkpoint['classifier']\\n\\n elif model_name == 'resnet50':\\n model = models.resnet50(pretrained=True)\\n # Make sure to set parameters as not trainable\\n for param in model.parameters():\\n param.requires_grad = False\\n model.fc = checkpoint['fc']\\n\\n # Load in the state dict\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n total_params = sum(p.numel() for p in model.parameters())\\n print(f'{total_params:,} total parameters.')\\n total_trainable_params = sum(\\n p.numel() for p in model.parameters() if p.requires_grad)\\n print(f'{total_trainable_params:,} total gradient parameters.')\\n\\n # Move to gpu\\n if multi_gpu:\\n model = nn.DataParallel(model)\\n\\n if train_on_gpu:\\n model = model.to('cuda')\\n\\n # Model basics\\n model.class_to_idx = checkpoint['class_to_idx']\\n model.idx_to_class = checkpoint['idx_to_class']\\n model.epochs = checkpoint['epochs']\\n\\n # Optimizer\\n optimizer = checkpoint['optimizer']\\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\n\\n return model, optimizer\",\n \"def load_checkpoint(self, checkpoint_dir):\\r\\n\\r\\n if not os.path.exists(checkpoint_dir):\\r\\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\\r\\n\\r\\n path = os.path.join(checkpoint_dir, 'model.pt')\\r\\n self.model.load_state_dict(torch.load(path, self.device))\\r\\n self.update()\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.monitor_best = checkpoint['monitor_best']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n self.train_logger = checkpoint['logger']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def unpack_checkpoint(\\n self,\\n checkpoint: Dict,\\n model=None,\\n criterion=None,\\n optimizer=None,\\n scheduler=None,\\n **kwargs,\\n ) -> None:\\n super().unpack_checkpoint(\\n checkpoint,\\n model=model,\\n criterion=criterion,\\n optimizer=optimizer,\\n scheduler=scheduler,\\n **kwargs,\\n )\\n\\n # NOTE: propper way to load state, docs:\\n # https://nvidia.github.io/apex/amp.html#checkpointing\\n if \\\"amp\\\" in checkpoint:\\n amp.load_state_dict(checkpoint[\\\"amp\\\"])\",\n \"def unpack_checkpoint(\\n self,\\n checkpoint: Dict,\\n model=None,\\n criterion=None,\\n optimizer=None,\\n scheduler=None,\\n **kwargs,\\n ) -> None:\\n super().unpack_checkpoint(\\n checkpoint,\\n model=model,\\n criterion=criterion,\\n optimizer=optimizer,\\n scheduler=scheduler,\\n **kwargs,\\n )\\n\\n # NOTE: propper way to load state, docs:\\n # https://nvidia.github.io/apex/amp.html#checkpointing\\n if \\\"amp\\\" in checkpoint:\\n amp.load_state_dict(checkpoint[\\\"amp\\\"])\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.mnt_best = checkpoint['monitor_best']\\n\\n # load model params from checkpoint.\\n if checkpoint['config']['name'] != self.config['name']:\\n self.logger.warning(\\n 'Warning: Architecture configuration given in config file is different from that of checkpoint. ' + \\\\\\n 'This may yield an exception while state_dict is being loaded.')\\n self.model.load_state_dict(checkpoint['model_state_dict'])\\n\\n # load optimizer state from checkpoint only when optimizer type is not changed. \\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\\n self.logger.warning('Warning: Optimizer type given in config file is different from that of checkpoint. ' + \\\\\\n 'Optimizer parameters not being resumed.')\\n self.optimizer.load_state_dict(checkpoint['model_optimizer'])\\n\\n # load scheduler state from checkpoint only when scheduler type is not changed\\n if checkpoint['config']['scheduler']['type'] != self.config['scheduler']['type']:\\n self.logger.warning('Warning: Scheduler type given in config file is different from that of checkpoint. ' + \\\\\\n 'Scheduler parameters not being resumed.')\\n self.scheduler.load_state_dict(checkpoint['model_scheduler'])\\n\\n self.train_logger = checkpoint['logger']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def load_checkpoint(self, model):\\n print(f\\\"load model {self.save_model_path}\\\")\\n model.load_state_dict(torch.load(self.save_model_path))\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.monitor_best = checkpoint['monitor_best']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n # 将参数全部放入GPU\\n if self.with_cuda:\\n for state in self.optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = v.cuda(self.device)\\n self.train_logger = checkpoint['logger']\\n self.config = checkpoint['config']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def load_checkpoint(model, model_name='model', validation_id=None):\\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\\n _load_model(model.module if type(model) is torch.nn.DataParallel else model, model_name, path=path, reload=True)\",\n \"def load_from_checkpoint(self, chkpt, section=None):\\n if section is None:\\n section = self.name\\n self.load_state_dict(chkpt[section])\",\n \"def load_G(self, G_checkpoint):\\n checkpoint = torch.load(G_checkpoint)\\n self.G.load_state_dict(checkpoint['gnet'])\\n self.gen_optim.load_state_dict(checkpoint['gopt'])\",\n \"def load_ckpt(args):\\n net = model.Model.load_from_checkpoint(args.ckpt)\\n net = net.eval().requires_grad_(False).to(args.device)\\n return net\",\n \"def load_snapshot(device, net, snapshot_name, optimizer=None):\\n\\ttry:\\n\\t\\tcheckpoint = torch.load(snapshot_name+'.pth', map_location=device)\\n\\t\\tnet.load_state_dict(checkpoint['model_state_dict'])\\n\\t\\tif optimizer:\\n\\t\\t\\trestore_optimizer(optimizer, checkpoint)\\n\\texcept:\\n\\t\\tcheckpoint = None\\t\\n\\treturn checkpoint\",\n \"def load_checkpoint(checkpoint_file: pl.Path) -> Optional[Dict[str, Any]]:\\n if checkpoint_file.exists():\\n logger.info(f\\\"Loading checkpoint {checkpoint_file}.\\\")\\n checkpoint = torch.load(str(checkpoint_file))\\n logger.info(f\\\"Done loading checkpoint from epoch {checkpoint['epoch']}.\\\")\\n else:\\n logger.warning(f\\\"No {checkpoint_file} checkpoint file found. Starting normal.\\\")\\n return checkpoint\",\n \"def load_checkpoint(self, checkpoint_path: Union[str, Path]) -> Dict[str, Any]:\\n # TODO: move to CheckpointIO\\n torch.cuda.empty_cache()\\n checkpoint_path = inject_model_parallel_rank(checkpoint_path)\\n return self.checkpoint_io.load_checkpoint(checkpoint_path)\",\n \"def load_training(saver, session, load_dir):\\n if tf.gfile.Exists(load_dir):\\n ckpt = tf.train.get_checkpoint_state(load_dir)\\n if ckpt and ckpt.model_checkpoint_path:\\n saver.restore(session, ckpt.model_checkpoint_path)\\n prev_step = extract_step(ckpt.model_checkpoint_path)\\n else:\\n tf.gfile.DeleteRecursively(load_dir)\\n tf.gfile.MakeDirs(load_dir)\\n prev_step = 0\\n else:\\n tf.gfile.MakeDirs(load_dir)\\n prev_step = 0\\n return prev_step\",\n \"def load_checkpoint(path: str, use_cuda: bool = True) -> dict:\\n assert os.path.isfile(path), \\\"Checkpoint %s not found\\\" % path\\n checkpoint = torch.load(path, map_location=\\\"cuda\\\" if use_cuda else \\\"cpu\\\")\\n return checkpoint\",\n \"def load_checkpoint(self, file):\\n \\\"\\\"\\\"Load \\\"\\\"\\\"\\n chkpnt = torch.load(file)\\n self.load_state_dict(chkpnt['model_state_dict'])\",\n \"def load_eval(saver, session, load_dir):\\n saver.restore(session, load_dir)\\n print('model loaded successfully')\\n return extract_step(load_dir)\",\n \"def load_checkpoint(checkpoint_directory,\\n session):\\n variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\\n # filter variables if needed.\\n print(variables)\\n saver_ob = tf.train.Saver(variables, max_to_keep=0)\\n os.makedirs(checkpoint_directory, exist_ok=True)\\n # verify if we don't have a checkpoint saved directly\\n step = 0\\n ckpt = tf.train.get_checkpoint_state(checkpoint_directory)\\n if ckpt and ckpt.model_checkpoint_path:\\n # Restores from checkpoint\\n model_checkpoint_path = ckpt.model_checkpoint_path\\n saver_ob.restore(session, model_checkpoint_path)\\n step = int(model_checkpoint_path.rsplit('-', 1)[1])\\n print('Model loaded = ', step)\\n return saver_ob, step\",\n \"def _restore_checkpoint(self, checkpoint_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(checkpoint_path))\\n checkpoint = torch.load(checkpoint_path)\\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\\n \\n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\\n print('Parameters are inconsistant, adapting model parameters ...')\\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\\n del pretrained_dict['1']\\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\\n self.model.load_state_dict(model_dict)\\n else:\\n print('Parameters are consistant, load state dict directly ...')\\n self.model.load_state_dict(checkpoint['state_dict'])\\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\\n # if self.with_cuda:\\n # for state in self.optimizer.state.values():\\n # for k, v in state.items():\\n # if isinstance(v, torch.Tensor):\\n # state[k] = v.cuda(self.device)\",\n \"def load_state(net, optimizer, scheduler, model_no=0, load_best=False):\\n logger.info(\\\"Initializing model and optimizer states...\\\")\\n base_path = \\\"./data/\\\"\\n checkpoint_path = os.path.join(base_path,\\\"test_checkpoint_%d.pth.tar\\\" % model_no)\\n best_path = os.path.join(base_path,\\\"test_model_best_%d.pth.tar\\\" % model_no)\\n start_epoch, best_pred, checkpoint = 0, 0, None\\n if (load_best == True) and os.path.isfile(best_path):\\n checkpoint = torch.load(best_path)\\n logger.info(\\\"Loaded best model.\\\")\\n elif os.path.isfile(checkpoint_path):\\n checkpoint = torch.load(checkpoint_path)\\n logger.info(\\\"Loaded checkpoint model.\\\")\\n if checkpoint != None:\\n start_epoch = checkpoint['epoch']\\n best_pred = checkpoint['best_acc']\\n net.load_state_dict(checkpoint['state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n scheduler.load_state_dict(checkpoint['scheduler'])\\n logger.info(\\\"Loaded model and optimizer.\\\") \\n return start_epoch, best_pred\",\n \"def load_checkpoint(checkpoint_path):\\n flat_checkpoint_dict = flatten_checkpoint(\\n parse_checkpoint(checkpoint_path), keep_empty_nodes=True)\\n return flat_checkpoint_dict\",\n \"def load_D( self, D_checkpoint):\\n checkpoint = torch.load(D_checkpoint)\\n self.D.load_state_dict(checkpoint['dnet'])\\n self.dis_optim.load_state_dict(checkpoint['gopt'])\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def load_checkpoint(fpath):\\n if fpath is None:\\n raise ValueError('File path is None')\\n if not osp.exists(fpath):\\n raise FileNotFoundError('File is not found at \\\"{}\\\"'.format(fpath))\\n map_location = None if torch.cuda.is_available() else 'cpu'\\n try:\\n checkpoint = torch.load(fpath, map_location=map_location)\\n except UnicodeDecodeError:\\n pickle.load = partial(pickle.load, encoding=\\\"latin1\\\")\\n pickle.Unpickler = partial(pickle.Unpickler, encoding=\\\"latin1\\\")\\n checkpoint = torch.load(\\n fpath, pickle_module=pickle, map_location=map_location\\n )\\n except Exception:\\n print('Unable to load checkpoint from \\\"{}\\\"'.format(fpath))\\n raise\\n return checkpoint\",\n \"def load_states(self, checkpoint):\\n raise NotImplementedError()\",\n \"def _load_checkpoint(cls, model: DeviceAwareModule, checkpoint_path: Path,\\n key_in_state_dict: str, use_gpu: bool) -> int:\\n logging.info(f\\\"Loading checkpoint {checkpoint_path}\\\")\\n checkpoint = ModelAndInfo.read_checkpoint(checkpoint_path, use_gpu)\\n\\n try:\\n state_dict = checkpoint[key_in_state_dict]\\n except KeyError:\\n logging.error(f\\\"Key {key_in_state_dict} not found in checkpoint\\\")\\n return False\\n\\n if isinstance(model, torch.nn.DataParallel):\\n result = model.module.load_state_dict(state_dict, strict=False)\\n else:\\n result = model.load_state_dict(state_dict, strict=False)\\n\\n if result.missing_keys:\\n logging.warning(f\\\"Missing keys in model checkpoint: {result.missing_keys}\\\")\\n if result.unexpected_keys:\\n logging.warning(f\\\"Unexpected keys in model checkpoint: {result.unexpected_keys}\\\")\\n\\n return checkpoint[ModelAndInfo.EPOCH_KEY]\",\n \"def load(self, sess, step=None):\\n if step==None:\\n ckpt_path = tf.train.latest_checkpoint(self.model.ckpt_dir)\\n else:\\n ckpt_path = os.path.join(self.model.ckpt_dir, 'model-'+str(step))\\n self.saver.restore(sess, ckpt_path)\\n step = tf.train.global_step(sess, self.gstep)\\n print('Load model at step {} from check point {}.'.format(step, ckpt_path))\",\n \"def load_checkpoint(self, session: tf.Session):\\n if not _load_checkpoint(session, str(self.info.checkpoint_path)):\\n tf_util.init_variables(session)\\n return False\\n else:\\n return True\",\n \"def load(self, model_path):\\n # TODO: include new params based on ConfigEnum\\n checkpoint = torch.load(model_path)\\n\\n self.image_size = checkpoint['image_size']\\n self.device = checkpoint['device']\\n self.fp16 = checkpoint['fp16']\\n self.accumulate_grad_steps = checkpoint['accumulate_grad_steps']\\n self.experiment_id = checkpoint['experiment_id']\\n self.experiment_tag = checkpoint['experiment_tag']\\n self.seed = checkpoint['seed']\\n self.train_batch_size = checkpoint['train_batch_size']\\n self.valid_batch_size = checkpoint['valid_batch_size']\\n self.test_batch_size = checkpoint['test_batch_size']\\n self.dataloader_num_workers = checkpoint['dataloader_num_workers']\\n self.train_dataloader_shuffle = checkpoint['train_dataloader_shuffle']\\n self.optimizer_type = checkpoint['optimizer_type']\\n self.optimizer_params = checkpoint['optimizer_params']\\n self.scheduler_type = checkpoint['scheduler_type']\\n self.scheduler_params = checkpoint['scheduler_params']\\n self.step_scheduler_after = checkpoint['step_scheduler_after']\\n self.step_scheduler_metric = checkpoint['step_scheduler_metric']\\n self.compute_train_loss_after = checkpoint['compute_train_loss_after']\\n self.compute_train_metric_after = checkpoint['compute_train_metric_after']\\n self.compute_valid_loss_after = checkpoint['compute_valid_loss_after']\\n self.compute_valid_metric_after = checkpoint['compute_valid_metric_after']\\n self.training_stopping_criteria = checkpoint['training_stopping_criteria']\\n self.stopping_criteria_params = checkpoint['stopping_criteria_params']\\n self.max_epoch = checkpoint['max_epoch']\\n self.train_on_all_data = checkpoint['train_on_all_data']\\n self.validate_after = checkpoint['validate_after']\\n self.validation_steps = checkpoint['validation_steps']\\n self.run_lr_range_test= checkpoint['run_lr_range_test']\\n self.sleep_in_epochs = checkpoint['sleep_in_epochs']\\n self.sleep_time = checkpoint['sleep_time']\\n self.checkpoint_epochs = checkpoint['checkpoint_epochs']\\n\\n self._best_score = checkpoint['_best_score']\\n self._current_score = checkpoint['_current_score']\\n self._counter = checkpoint['_counter']\\n self.metrics = checkpoint['metrics']\\n self.current_epoch = checkpoint['current_epoch']\\n self.current_train_batch = checkpoint['current_train_batch']\\n self.current_valid_batch = checkpoint['current_valid_batch']\\n self.num_train_samples = checkpoint['num_train_samples']\\n self.num_train_iterations = checkpoint['num_train_iterations']\\n self.checkpoint_snapshot = checkpoint['checkpoint_snapshot'] \\n\\n # initialize optimizer, scheduler, and gradient scaler\\n self.configure_optimizers()\\n self.configure_schedulers()\\n \\n if self.fp16:\\n self.scaler = torch.cuda.amp.GradScaler()\\n\\n if self.model:\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.model.to(self.device)\\n\\n if self.optimizer:\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n if self.scheduler:\\n self.scheduler.load_state_dict(checkpoint['scheduler'])\\n\\n #if self.scaler:\\n # self.scaler.load_state_dict(checkpoint['scaler'])\",\n \"def load_state_dict(self, checkpoint):\\n self.net.load_state_dict(checkpoint['Net'])\\n self.optimizer.load_state_dict(checkpoint['Optimizer'])\\n\\n if ADVERSARIAL_FLAG:\\n self.adv_net.load_state_dict(checkpoint['AdvNet'])\\n self.adv_optimizer.load_state_dict(checkpoint['AdvOptimizer'])\\n\\n self.history = checkpoint['History']\\n self.stats = checkpoint['Stats']\\n\\n # The following loops are used to fix a bug that was\\n # discussed here: https://github.com/pytorch/pytorch/issues/2830\\n # (it is supposed to be fixed in recent PyTorch version)\\n for state in self.optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = v.to(self.net.device)\\n if ADVERSARIAL_FLAG:\\n for adv_state in self.adv_optimizer.state.values():\\n for k, v in adv_state.items():\\n if isinstance(v, torch.Tensor):\\n adv_state[k] = v.to(self.adv_net.device)\",\n \"def load(self, path):\\n\\n filename = self.__path(path, prefix=None)\\n chkpt = th.load(filename, map_location=\\\"cpu\\\") # TODO: check behavior\\n\\n if self.model is not None and chkpt[\\\"model\\\"] is not None:\\n log.debug(\\\"Loading model state dict\\\")\\n self.model.load_state_dict(chkpt[\\\"model\\\"])\\n\\n if \\\"optimizers\\\" in chkpt.keys():\\n if self.optimizers is not None and chkpt[\\\"optimizers\\\"] is not None:\\n try:\\n for opt, state in zip(self.optimizers,\\n chkpt[\\\"optimizers\\\"]):\\n log.debug(\\\"Loading optimizers state dict for %s\\\", opt)\\n opt.load_state_dict(state)\\n except:\\n # We do not raise an error here, e.g. in case the user simply\\n # changes optimizer\\n log.warning(\\\"Could not load optimizer state dicts, \\\"\\n \\\"starting from scratch\\\")\\n\\n if \\\"schedulers\\\" in chkpt.keys():\\n if self.schedulers is not None and chkpt[\\\"schedulers\\\"] is not None:\\n try:\\n for s, state in zip(self.schedulers,\\n chkpt[\\\"schedulers\\\"]):\\n log.debug(\\\"Loading scheduler state dict for %s\\\", s)\\n s.load_state_dict(state)\\n except:\\n log.warning(\\\"Could not load scheduler state dicts, \\\"\\n \\\"starting from scratch\\\")\\n\\n log.debug(\\\"Loaded checkpoint \\\\\\\"{}\\\\\\\"\\\".format(filename))\\n return tuple(chkpt[k] for k in [\\\"extras\\\", \\\"meta\\\"])\",\n \"def load_actor(self, checkpoint):\\n \\n model = torch.load(checkpoint)\\n self.actor_local.load_state_dict(model)\",\n \"def load_checkpoint(self, checkpoint_filepath=None, verbose=True):\\n if checkpoint_filepath:\\n print('loading', checkpoint_filepath, flush=True)\\n optimistic_restore(self._session, checkpoint_filepath, verbose=verbose)\\n return True\\n else:\\n checkpoints = retrieve_all_checkpoints(self._checkpoints_path) + retrieve_all_checkpoints(self._recovery_checkpoints_path)\\n\\n if checkpoints:\\n last_checkpoint = sorted(checkpoints)[-1][1]\\n print('loading', last_checkpoint, flush=True)\\n optimistic_restore(self._session, last_checkpoint, verbose=verbose)\\n return True\\n else:\\n print('nothing to restore. no checkpoint found.', flush=True)\\n return False\",\n \"def load_weights(self, checkpoint_path, sess=None):\\n\\n if sess is None:\\n sess = tf.get_default_session()\\n assert sess is not None\\n\\n saver = tf.train.Saver(self.variables_to_restore)\\n saver.restore(sess, checkpoint_path)\",\n \"def load_weights(self, checkpoint_path, sess=None):\\n\\n if sess is None:\\n sess = tf.get_default_session()\\n assert sess is not None\\n\\n saver = tf.train.Saver(self.variables_to_restore)\\n saver.restore(sess, checkpoint_path)\",\n \"def load_weights(self, checkpoint_path, sess=None):\\n\\n if sess is None:\\n sess = tf.get_default_session()\\n assert sess is not None\\n\\n saver = tf.train.Saver(self.variables_to_restore)\\n saver.restore(sess, checkpoint_path)\",\n \"def get_checkpoint(model, checkpoint='-1'):\\n if not os.path.isfile(os.path.join(model, \\\"checkpoint\\\")):\\n sys.exit(\\\"[ERROR] Cannot find checkpoint in %s.\\\" % model)\\n ckpt = tf.train.get_checkpoint_state(model)\\n\\n model_checkpoint_path = ckpt.model_checkpoint_path\\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\\n\\n if not ckpt or not model_checkpoint_path:\\n sys.exit(\\\"[ERROR] Cannot read checkpoint %s.\\\" % os.path.join(model, \\\"checkpoint\\\"))\\n\\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\\n steps = sorted(steps)\\n if checkpoint == \\\"last\\\":\\n tf.logging.info(\\\"Load the last saved model.\\\")\\n checkpoint = steps[-1]\\n else:\\n checkpoint = int(checkpoint)\\n if checkpoint == -1:\\n tf.logging.info(\\\"Load the best model according to valid_loss\\\")\\n min_epoch = -1\\n min_loss = 1e10\\n with open(os.path.join(model, \\\"valid_loss\\\")) as f:\\n for line in f.readlines():\\n epoch, loss, eer = line.split(\\\" \\\")\\n epoch = int(epoch)\\n loss = float(loss)\\n if loss < min_loss:\\n min_loss = loss\\n min_epoch = epoch\\n # Add 1 to min_epoch since epoch is 0-based\\n config_json = os.path.join(model, \\\"config.json\\\")\\n params = Params(config_json)\\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\\n tf.logging.info(\\\"The checkpoint is %d\\\" % checkpoint)\\n assert checkpoint in steps, \\\"The checkpoint %d not in the model directory\\\" % checkpoint\\n\\n model_checkpoint_path = model_checkpoint_path.rsplit(\\\"-\\\", 1)[0] + \\\"-\\\" + str(checkpoint)\\n model_checkpoint_path = os.path.join(model, os.path.basename(model_checkpoint_path))\\n\\n with open(os.path.join(model, \\\"checkpoint\\\"), \\\"w\\\") as f:\\n f.write(\\\"model_checkpoint_path: \\\\\\\"%s\\\\\\\"\\\\n\\\" % model_checkpoint_path)\\n for checkpoint in all_model_checkpoint_paths:\\n checkpoint_new = os.path.join(model, os.path.basename(checkpoint))\\n f.write(\\\"all_model_checkpoint_paths: \\\\\\\"%s\\\\\\\"\\\\n\\\" % checkpoint_new)\\n return model_checkpoint_path\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83664644","0.80974585","0.80771816","0.80259275","0.7999482","0.79903316","0.7857532","0.7640271","0.75701135","0.748829","0.7443241","0.74228936","0.7389801","0.7375046","0.7372049","0.7315069","0.7312009","0.72855306","0.725681","0.7247519","0.72201985","0.72201985","0.72147804","0.7209309","0.71791726","0.7172253","0.71158737","0.7098844","0.70984185","0.7015792","0.70148826","0.70143586","0.7003345","0.7003345","0.70000845","0.6930754","0.69023585","0.6900019","0.6882023","0.68749577","0.68699276","0.6853341","0.68064564","0.68055785","0.6797791","0.6789168","0.67880154","0.6779343","0.67526346","0.6739233","0.6728988","0.6724793","0.6701432","0.6689497","0.666077","0.6658363","0.6636807","0.6628691","0.6610083","0.6576368","0.6575941","0.65691924","0.6563615","0.6562063","0.6562063","0.6540874","0.6534417","0.6487161","0.64807385","0.6464343","0.6454532","0.64472795","0.6441939","0.64327425","0.64193445","0.6413526","0.6407017","0.6399171","0.6387763","0.637766","0.63550097","0.6342925","0.6338328","0.63344276","0.6327162","0.6327162","0.63226485","0.6314014","0.63058704","0.63001436","0.62904066","0.6287508","0.626691","0.62554336","0.625303","0.62445664","0.6229745","0.6229745","0.6229745","0.6228728"],"string":"[\n \"0.83664644\",\n \"0.80974585\",\n \"0.80771816\",\n \"0.80259275\",\n \"0.7999482\",\n \"0.79903316\",\n \"0.7857532\",\n \"0.7640271\",\n \"0.75701135\",\n \"0.748829\",\n \"0.7443241\",\n \"0.74228936\",\n \"0.7389801\",\n \"0.7375046\",\n \"0.7372049\",\n \"0.7315069\",\n \"0.7312009\",\n \"0.72855306\",\n \"0.725681\",\n \"0.7247519\",\n \"0.72201985\",\n \"0.72201985\",\n \"0.72147804\",\n \"0.7209309\",\n \"0.71791726\",\n \"0.7172253\",\n \"0.71158737\",\n \"0.7098844\",\n \"0.70984185\",\n \"0.7015792\",\n \"0.70148826\",\n \"0.70143586\",\n \"0.7003345\",\n \"0.7003345\",\n \"0.70000845\",\n \"0.6930754\",\n \"0.69023585\",\n \"0.6900019\",\n \"0.6882023\",\n \"0.68749577\",\n \"0.68699276\",\n \"0.6853341\",\n \"0.68064564\",\n \"0.68055785\",\n \"0.6797791\",\n \"0.6789168\",\n \"0.67880154\",\n \"0.6779343\",\n \"0.67526346\",\n \"0.6739233\",\n \"0.6728988\",\n \"0.6724793\",\n \"0.6701432\",\n \"0.6689497\",\n \"0.666077\",\n \"0.6658363\",\n \"0.6636807\",\n \"0.6628691\",\n \"0.6610083\",\n \"0.6576368\",\n \"0.6575941\",\n \"0.65691924\",\n \"0.6563615\",\n \"0.6562063\",\n \"0.6562063\",\n \"0.6540874\",\n \"0.6534417\",\n \"0.6487161\",\n \"0.64807385\",\n \"0.6464343\",\n \"0.6454532\",\n \"0.64472795\",\n \"0.6441939\",\n \"0.64327425\",\n \"0.64193445\",\n \"0.6413526\",\n \"0.6407017\",\n \"0.6399171\",\n \"0.6387763\",\n \"0.637766\",\n \"0.63550097\",\n \"0.6342925\",\n \"0.6338328\",\n \"0.63344276\",\n \"0.6327162\",\n \"0.6327162\",\n \"0.63226485\",\n \"0.6314014\",\n \"0.63058704\",\n \"0.63001436\",\n \"0.62904066\",\n \"0.6287508\",\n \"0.626691\",\n \"0.62554336\",\n \"0.625303\",\n \"0.62445664\",\n \"0.6229745\",\n \"0.6229745\",\n \"0.6229745\",\n \"0.6228728\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7403394"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":4481,"cells":{"query":{"kind":"string","value":"Creates an optimizer and loads its state from a checkpoint."},"document":{"kind":"string","value":"def try_create_optimizer_and_load_from_checkpoint(self) -> bool:\n self.create_optimizer()\n if self.checkpoint_path:\n return self.try_load_checkpoint_for_optimizer()\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\n self.model.load_state_dict(checkpoint[\"model_state_dict\"])\n self.optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n return self","def create_optimizer(self) -> None:\n # Make sure model is created before we create optimizer\n if self._model is None:\n raise ValueError(\"Model checkpoint must be created before optimizer checkpoint can be loaded.\")\n\n # Select optimizer type\n if self.config.optimizer_type in [OptimizerType.Adam, OptimizerType.AMSGrad]:\n self._optimizer = torch.optim.Adam(self._model.parameters(), self.config.l_rate,\n self.config.adam_betas, self.config.opt_eps, self.config.weight_decay,\n amsgrad=self.config.optimizer_type == OptimizerType.AMSGrad)\n elif self.config.optimizer_type == OptimizerType.SGD:\n self._optimizer = torch.optim.SGD(self._model.parameters(), self.config.l_rate, self.config.momentum,\n weight_decay=self.config.weight_decay)\n elif self.config.optimizer_type == OptimizerType.RMSprop:\n self._optimizer = RMSprop(self._model.parameters(), self.config.l_rate, self.config.rms_alpha,\n self.config.opt_eps,\n self.config.weight_decay, self.config.momentum)\n else:\n raise NotImplementedError(f\"Optimizer type {self.config.optimizer_type.value} is not implemented\")","def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\n print(\"Load checkpoint from: {}\".format(path))\n state_dict, optimizer_state = _load(path)\n\n model.load_dict(state_dict)\n if not reset_optimizer and optimizer is not None:\n if optimizer_state is not None:\n print(\"[loading] Load optimizer state from {}\".format(path))\n optimizer.load(optimizer_state)\n\n return model","def load_checkpoint(checkpoint_path, model, optimizer=None):\n if not os.path.exists(checkpoint_path):\n raise IOError(f\"Checkpoint '{checkpoint_path}' does not exist\")\n\n state = torch.load(checkpoint_path)\n try:\n model.load_state_dict(state['model_state_dict'])\n except BaseException as e:\n print('Failed to do something: ' + str(e))\n\n if optimizer is not None:\n try:\n optimizer.load_state_dict(state['optimizer_state_dict'])\n except Exception as e:\n print(e)\n\n return state","def load_checkpoint(checkpoint, model, optimizer=None):\n model_state_dict, optimizer_state_dict = torch.load(checkpoint)\n model.load_state_dict(model_state_dict)\n\n if optimizer is not None:\n optimizer.load_state_dict(optimizer_state_dict)","def opt_from_checkpoint(\n checkpoint_path: str,\n config_path: Optional[str] = None,\n extra_bindings=tuple([])\n) -> Optimizer:\n\n if config_path is None:\n config_path = \"/\".join(checkpoint_path.split(\"/\")[:-1]) + \"/config.gin\"\n\n logging.info(\"Restoring configs from: %s\", config_path)\n with gin.unlock_config():\n scope = f\"opt_from_checkpoint__{str(uuid.uuid4()).replace('-', '_')}\"\n with gin.config_scope(None):\n with gin.config_scope(scope):\n if config_path:\n with file_open(config_path, \"rb\") as f:\n content = bytes(f.read()).decode(\"utf-8\")\n\n # gin writes out multi line sometimes, undo this.\n content = content.replace(\"\\\\\\n\", \"\")\n\n def maybe_add_scope(c):\n # filter out train as this overlaps with outer_training.\n if c.startswith(\"#\"):\n return None\n if \"=\" in c:\n return scope + \"/\" + c\n return c\n\n bindings = [maybe_add_scope(c) for c in content.split(\"\\n\")]\n bindings = [b for b in bindings if b]\n bindings = bindings + [maybe_add_scope(c) for c in extra_bindings]\n\n logging.info(\"Parsing bindings\")\n for b in bindings:\n logging.info(b)\n print(b)\n gin.parse_config(bindings, skip_unknown=True)\n\n configurable = gin.query_parameter(f\"{scope}/run_train.lopt\")\n if isinstance(configurable, gin.config._UnknownConfigurableReference): # pylint: disable=protected-access\n raise ValueError(\"Gin couldn't find the learned optimizer in current\"\n \" imports. Did you forget to import the module?\")\n\n # with summary.summary_scope(\"opt_from_checkpoint\"):\n lopt = configurable.configurable.wrapped()\n theta = lopt.init(jax.random.PRNGKey(0))\n logging.info(f\"Restoring checkpoint {checkpoint_path}\") # pylint: disable=logging-fstring-interpolation\n ckpt = ParameterCheckpoint(theta, \"\", 0)\n ckpt = load_state(checkpoint_path, ckpt)\n opt = lopt.opt_fn(ckpt.params)\n return opt\n # wrapped = _GinScopeClass(opt, scope)\n # For now, just add the lopt to the returned class.\n # TODO(lmetz) change this api to return a more structured class?\n # wrapped.lopt = lopt\n # return wrapped # type: ignore","def _load(checkpoint_path):\n state_dict, optimizer_state = dg.load_persistables(dirname=checkpoint_path)\n return state_dict, optimizer_state","def load_checkpoint(checkpoint_path, model, optimizer=None,\n model_key='model_state_dict', optimizer_key='optimizer_state_dict'):\n if not os.path.exists(checkpoint_path):\n raise IOError(f\"Checkpoint '{checkpoint_path}' does not exist\")\n\n state = torch.load(checkpoint_path, map_location='cpu')\n model.load_state_dict(state[model_key])\n\n if optimizer is not None:\n optimizer.load_state_dict(state[optimizer_key])\n\n return state","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint)\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load_checkpoint(checkpoint_path, model, optimizer=None):\n if not os.path.exists(checkpoint_path):\n raise IOError(\"Checkpoint '{}' does not exist\".format(checkpoint_path))\n\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else 'cpu')\n state = torch.load(checkpoint_path, map_location=\"cuda:0\")\n model.load_state_dict(state['model_state_dict'])\n\n if optimizer is not None:\n optimizer.load_state_dict(state['optimizer_state_dict'])\n\n return state","def try_load_checkpoint_for_optimizer(self) -> bool:\n\n if self._optimizer is None:\n raise ValueError(\"Optimizer must be created before optimizer checkpoint can be loaded.\")\n\n if not self.checkpoint_path:\n logging.warning(\"No checkpoint path provided.\")\n return False\n\n if not self.checkpoint_path.is_file():\n logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')\n return False\n\n logging.info(f\"Loading checkpoint {self.checkpoint_path}\")\n checkpoint = ModelAndInfo.read_checkpoint(self.checkpoint_path, self.config.use_gpu)\n\n try:\n state_dict = checkpoint[ModelAndInfo.OPTIMIZER_STATE_DICT_KEY]\n except KeyError:\n logging.error(f\"Key {ModelAndInfo.OPTIMIZER_STATE_DICT_KEY} not found in checkpoint\")\n return False\n\n self._optimizer.load_state_dict(state_dict)\n\n logging.info(f\"Loaded optimizer from checkpoint (epoch: {checkpoint[ModelAndInfo.EPOCH_KEY]})\")\n self.checkpoint_epoch = checkpoint[ModelAndInfo.EPOCH_KEY]\n return True","def load(self, path):\n checkpoint = torch.load(path)\n self.load_state_dict(checkpoint['model_state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])","def load(self, path):\n checkpoint = torch.load(path)\n self.load_state_dict(checkpoint['model_state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])","def LoadProgramState(self, restored_checkpoint_path=None, sess=None):\n pass","def create_optimizer(net, optimizer_state_dict, learning_rate, device='cuda'):\n # define optimizer\n optimizer = optim.Adam([{\n 'params': net.net.parameters(),\n 'initial_lr': learning_rate\n }])\n # load optimizer checkpoint if available\n if optimizer_state_dict is not None:\n target_device = 'cpu' if device == 'cpu' else 'cuda'\n # load the optimizer weights\n optimizer.load_state_dict(optimizer_state_dict)\n for state in optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = getattr(v, target_device)()\n return optimizer","def load_model_from_checkpoint(self, path: str):\n ckpt = torch.load(path, map_location='cpu')\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\n self.net_q.head.load_state_dict(ckpt['head'])\n self.net_ps.load_state_dict(ckpt['net_ps'])\n self.net_k.load_state_dict(ckpt['net_k'])\n self.queue.load_state_dict(ckpt['queue'])\n self.optimizer.load_state_dict(ckpt['optimizer'])\n if 'scheduler' in ckpt:\n self.scheduler.load_stae_dict(ckpt['scheduler'])\n self.move_optimizer_states(self.optimizer, self.local_rank)","def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\n print(\"Loading checkpoint: {}\".format(checkpoint_path))\n state = torch.load(checkpoint_path)\n self.model.load_state_dict(state['state_dict'])\n self.optimizer.load_state_dict(state['optim_dict'])\n\n if continue_from_epoch:\n self.epoch = state['epoch']","def create_optimizer(parameters, optimizer_class, optim_params, model_name='model'):\n opt = optimizer_class(parameters, **optim_params)\n if special_parameters.load_model:\n _load_optimizer(opt, model_name)\n return opt","def load_state_dict(self, checkpoint):\n self.net.load_state_dict(checkpoint['Net'])\n self.optimizer.load_state_dict(checkpoint['Optimizer'])\n\n if ADVERSARIAL_FLAG:\n self.adv_net.load_state_dict(checkpoint['AdvNet'])\n self.adv_optimizer.load_state_dict(checkpoint['AdvOptimizer'])\n\n self.history = checkpoint['History']\n self.stats = checkpoint['Stats']\n\n # The following loops are used to fix a bug that was\n # discussed here: https://github.com/pytorch/pytorch/issues/2830\n # (it is supposed to be fixed in recent PyTorch version)\n for state in self.optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = v.to(self.net.device)\n if ADVERSARIAL_FLAG:\n for adv_state in self.adv_optimizer.state.values():\n for k, v in adv_state.items():\n if isinstance(v, torch.Tensor):\n adv_state[k] = v.to(self.adv_net.device)","def load_model(agent, optimizer, model_file):\n checkpoint = torch.load(model_file)\n episode = checkpoint['epoch']\n agent.load_state_dict(checkpoint['model_state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n return episode","def load_checkpoint(self, filename, load_optim=True):\n extra_state, optim_history, last_optim_state = \\\n utils.load_model_state(filename, self.get_model())\n\n if last_optim_state is not None:\n # rebuild optimizer after loading model, since params may have changed\n #self.optimizer = optim.build_optimizer(self.args, self.model.parameters())\n self.lr_scheduler = lr_scheduler.build_lr_scheduler(self.args, self.optimizer)\n\n if load_optim:\n self._optim_history = optim_history\n # only reload optimizer and lr_scheduler if they match\n last_optim = self._optim_history[-1]\n if last_optim['criterion_name'] == self.criterion.__class__.__name__:\n self.lr_scheduler.load_state_dict(last_optim['lr_scheduler_state'])\n if last_optim['optimizer_name'] == self.optimizer.__class__.__name__:\n self.optimizer.load_state_dict(last_optim_state)\n\n self._num_updates = last_optim['num_updates']\n\n return extra_state","def _create_optimizer(self):\n\n with tf.name_scope(\"optimizer\"):\n self.train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.loss)","def create_optimizer(self, context, optimizer, host):\n pass","def _load_state_dict(optimizer, state: dict) -> None:\n if is_scheduler(optimizer):\n optimizer.load_state_dict(state[\"scheduler\"])\n optimizer.optimizer.load_state_dict(state[\"optimizer\"])\n else:\n optimizer.load_state_dict(state)","def load_state(net, optimizer, scheduler, model_no=0, load_best=False):\n logger.info(\"Initializing model and optimizer states...\")\n base_path = \"./data/\"\n checkpoint_path = os.path.join(base_path,\"test_checkpoint_%d.pth.tar\" % model_no)\n best_path = os.path.join(base_path,\"test_model_best_%d.pth.tar\" % model_no)\n start_epoch, best_pred, checkpoint = 0, 0, None\n if (load_best == True) and os.path.isfile(best_path):\n checkpoint = torch.load(best_path)\n logger.info(\"Loaded best model.\")\n elif os.path.isfile(checkpoint_path):\n checkpoint = torch.load(checkpoint_path)\n logger.info(\"Loaded checkpoint model.\")\n if checkpoint != None:\n start_epoch = checkpoint['epoch']\n best_pred = checkpoint['best_acc']\n net.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n scheduler.load_state_dict(checkpoint['scheduler'])\n logger.info(\"Loaded model and optimizer.\") \n return start_epoch, best_pred","def load_from_checkpoint(self, path):\n print(f'# loading trainer state from {path}')\n checkpoint = torch.load(path)\n self.load(checkpoint)","def load_ckp(checkpoint_fpath, model, optimizer, device):\n\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\n model.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n valid_acc = checkpoint['valid_acc'] \n return model, optimizer, checkpoint['epoch'], valid_acc","def load_checkpoint(self, model, optimizers):\n self.epoch = get_last_epoch(self.log_path)\n\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\n model.load_state_dict(model_state_dict)\n\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\n for opt_ind in range(len(optimizers)):\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\n\n schedulers = load_sched(optimizers, self.epoch)\n\n return model, optimizers, schedulers","def load_model(path, model, optimizer):\n print(\"LOADING MODEL...\")\n ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)\n status = ckpt.restore(tf.train.latest_checkpoint(path))\n ckpt_manager = tf.train.CheckpointManager(\n checkpoint=ckpt, \n directory=FLAGS.model_dir, \n max_to_keep=3 \n )\n return model, optimizer, ckpt, ckpt_manager","def testSaveAndLoad(self):\n layers = (2, 3)\n net_options = {\"layers\": layers, \"initializer\": \"zeros\"}\n num_unrolls = 2\n num_epochs = 1\n\n problem = problems.simple()\n\n # Original optimizer.\n with tf.Graph().as_default() as g1:\n optimizer = meta.MetaOptimizer(net=dict(\n net=\"CoordinateWiseDeepLSTM\",\n net_options=net_options))\n minimize_ops = optimizer.meta_minimize(problem, 3)\n\n with self.test_session(graph=g1) as sess:\n sess.run(tf.global_variables_initializer())\n train(sess, minimize_ops, 1, 2)\n\n # Save optimizer.\n tmp_dir = tempfile.mkdtemp()\n save_result = optimizer.save(sess, path=tmp_dir)\n net_path = next(iter(save_result))\n\n # Retrain original optimizer.\n cost, x = train(sess, minimize_ops, num_unrolls, num_epochs)\n\n # Load optimizer and retrain in a new session.\n with tf.Graph().as_default() as g2:\n optimizer = meta.MetaOptimizer(net=dict(\n net=\"CoordinateWiseDeepLSTM\",\n net_options=net_options,\n net_path=net_path))\n minimize_ops = optimizer.meta_minimize(problem, 3)\n\n with self.test_session(graph=g2) as sess:\n sess.run(tf.global_variables_initializer())\n cost_loaded, x_loaded = train(sess, minimize_ops, num_unrolls, num_epochs)\n\n # The last cost should be the same.\n self.assertAlmostEqual(cost, cost_loaded, places=3)\n self.assertAlmostEqual(x[0], x_loaded[0], places=3)\n\n # Cleanup.\n os.remove(net_path)\n os.rmdir(tmp_dir)","def on_stage_start(self, state: _State):\n optimizer = state.get_attr(\n key=\"optimizer\", inner_key=self.optimizer_key\n )\n assert optimizer is not None\n self._optimizer = optimizer","def build_trainer(restore_state=None, train_policies=None, config=None):\n \n print(\"Using config\")\n print(config)\n cls = PPOTrainer\n trainer = cls(config=config)\n env = trainer.workers.local_worker().env\n if restore_state is not None:\n trainer.restore_from_object(restore_state)\n return trainer","def load_checkpoint(tag, params, model):\r\n file_name = os.path.join(\"saved_models\", params.path, tag + \".pt\")\r\n logger.info(\"Load checkpoint from %s\" % file_name)\r\n if os.path.exists(file_name):\r\n checkpoint = torch.load(file_name, map_location='cpu')\r\n params.training_id = checkpoint['training_id']\r\n logger.info(checkpoint['training_id'])\r\n model.global_step = checkpoint['global_step']\r\n model.load_state_dict(checkpoint['model'])\r\n for i, optimizer in enumerate(model.optimizers):\r\n optimizer.load_state_dict(checkpoint['optimizers'][i])\r\n else:\r\n raise Exception(\"Checkpoint not found.\")","def load(self, path):\n file = open(path, 'rb')\n state = pickle.load(file)\n\n self.opt_state = optimizers.pack_optimizer_state(state)","def _load_optimizer(self):\n # loss function\n with tf.variable_scope(\"forward\"):\n self.loss_fwd = tf.nn.seq2seq.sequence_loss(self.dec_outputs_fwd,\n self.labels, self.weights, self.vocab_size)\n\n # optimizer\n # self.optimizer_fwd = tf.train.MomentumOptimizer(self.learning_rate,\n # self.momentum)\n self.optimizer_fwd = tf.train.GradientDescentOptimizer(self.learning_rate)\n self.train_op_fwd = self.optimizer_fwd.minimize(self.loss_fwd)\n\n with tf.variable_scope(\"backward\"):\n self.loss_bwd = tf.nn.seq2seq.sequence_loss(self.dec_outputs_bwd,\n self.labels, self.weights, self.vocab_size)\n\n # optimizer\n # self.optimizer_bwd = tf.train.MomentumOptimizer(self.learning_rate,\n # self.momentum)\n self.optimizer_bwd = tf.train.GradientDescentOptimizer(self.learning_rate)\n self.train_op_bwd = self.optimizer_bwd.minimize(self.loss_bwd)","def load_pretrained(model, fname, optimizer=None):\n if os.path.isfile(fname):\n print(\"=> loading checkpoint '{}'\".format(fname))\n checkpoint = torch.load(fname)\n model.load_state_dict(checkpoint['state_dict'])\n if optimizer is not None:\n optimizer.load_state_dict(checkpoint['optimizer'])\n return model, optimizer, checkpoint['epoch']\n else:\n return model\n else:\n raise Exception(\"=> no checkpoint found at '{}'\".format(fname))","def load_checkpoint(args, trainer, epoch_itr):\n os.makedirs(os.path.join(args.save_dir, 'checkpoints'), exist_ok=True)\n checkpoint_path = os.path.join(args.save_dir, 'checkpoints', args.restore_file)\n if os.path.isfile(checkpoint_path):\n extra_state = trainer.load_checkpoint(checkpoint_path)\n if extra_state is not None:\n # replay train iterator to match checkpoint\n epoch_itr.load_state_dict(extra_state['train_iterator'])\n\n print('| loaded checkpoint {} (epoch {} @ {} updates)'.format(\n checkpoint_path, epoch_itr.epoch, trainer.get_num_updates()))\n\n trainer.lr_step(epoch_itr.epoch)\n trainer.lr_step_update(trainer.get_num_updates())\n if 'best' in extra_state:\n save_checkpoint.best = extra_state['best']","def _resume_checkpoint(self, resume_path, model, optimizer):\n if not resume_path:\n return model, optimizer\n\n self.logger.info(f'Loading checkpoint: {resume_path}')\n checkpoint = torch.load(resume_path)\n model.load_state_dict(checkpoint['state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed.\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\n self.logger.warning(\"Warning: Optimizer type given in config file is different from \"\n \"that of checkpoint. Optimizer parameters not being resumed.\")\n else:\n optimizer.load_state_dict(checkpoint['optimizer'])\n\n self.logger.info(f'Checkpoint \"{resume_path}\" loaded')\n return model, optimizer","def _create_train_op(self):\n if self.optim_type == 'adagrad':\n self.optimizer = tf.train.AdagradOptimizer(self.learning_rate)\n elif self.optim_type == 'adam':\n self.optimizer = tf.train.AdamOptimizer(self.learning_rate)\n elif self.optim_type == 'rprop':\n self.optimizer = tf.train.RMSPropOptimizer(self.learning_rate)\n elif self.optim_type == 'sgd':\n self.optimizer = tf.train.GradientDescentOptimizer(self.learning_rate)\n else:\n raise NotImplementedError('Unsupported optimizer: {}'.format(self.optim_type))\n self.train_op = self.optimizer.minimize(self.loss)","def _create_train_op(self):\n if self.optim_type == 'adagrad':\n self.optimizer = tf.train.AdagradOptimizer(self.learning_rate)\n elif self.optim_type == 'adam':\n self.optimizer = tf.train.AdamOptimizer(self.learning_rate)\n elif self.optim_type == 'rprop':\n self.optimizer = tf.train.RMSPropOptimizer(self.learning_rate)\n elif self.optim_type == 'sgd':\n self.optimizer = tf.train.GradientDescentOptimizer(self.learning_rate)\n else:\n raise NotImplementedError('Unsupported optimizer: {}'.format(self.optim_type))\n self.train_op = self.optimizer.minimize(self.loss)","def init_optimizer(self, kvstore='local', optimizer='sgd',\n optimizer_params=(('learning_rate', 0.01),), force_init=False):\n assert self.binded and self.params_initialized\n\n if self.optimizer_initialized and not force_init:\n self.logger.warning('optimizer already initialized, ignoring...')\n return\n\n if self._params_dirty:\n self._sync_params_from_devices()\n\n (kvstore, update_on_kvstore) = \\\n mx.model._create_kvstore(kvstore, len(self._context), self._arg_params)\n\n batch_size = self._exec_group.batch_size\n if kvstore and 'dist' in kvstore.type and '_sync' in kvstore.type:\n batch_size *= kvstore.num_workers\n rescale_grad = 1.0 / batch_size\n\n\n idx2name = {}\n if update_on_kvstore:\n idx2name.update(enumerate(self._exec_group.param_names))\n else:\n for k in range(len(self._context)):\n idx2name.update({i*len(self._context)+k: n\n for i, n in enumerate(self._exec_group.param_names)})\n name2idx = {}\n for k, v in idx2name.items():\n if v not in name2idx:\n name2idx[v] = []\n name2idx[v].append(k)\n\n if isinstance(optimizer, str):\n optimizer_params = dict(optimizer_params)\n if 'rescale_grad' not in optimizer_params:\n optimizer_params['rescale_grad'] = rescale_grad\n optimizer = mx.optimizer.create(optimizer,\n sym=self.symbol, param_idx2name=idx2name,\n **optimizer_params)\n else:\n assert isinstance(optimizer, mx.optimizer.Optimizer)\n if optimizer.rescale_grad != rescale_grad:\n #pylint: disable=no-member\n warnings.warn(\n \"Optimizer created manually outside Module but rescale_grad \" +\n \"is not normalized to 1.0/batch_size/num_workers (%s vs. %s). \"%(\n optimizer.rescale_grad, rescale_grad) +\n \"Is this intended?\", stacklevel=2)\n if len(optimizer.idx2name):\n warnings.warn(\"The idx2name of the optimizer is overwrote by ModuleEXT\")\n # overwrite optimizer.idx2name\n optimizer.idx2name = idx2name.copy()\n\n self._param_idx2name = idx2name \n self._param_name2idx = name2idx\n self._optimizer = optimizer\n self._kvstore = kvstore\n self._update_on_kvstore = update_on_kvstore\n self._updater = None\n\n if kvstore:\n if self._compression_params:\n kvstore.set_gradient_compression(self._compression_params)\n # copy initialized local parameters to kvstore\n _initialize_kvstore(kvstore=kvstore,\n param_arrays=self._exec_group.param_arrays,\n arg_params=self._arg_params,\n param_names=self._param_names,\n update_on_kvstore=update_on_kvstore)\n if update_on_kvstore:\n kvstore.set_optimizer(self._optimizer)\n else:\n self._updater = mx.optimizer.get_updater(optimizer)\n\n self.optimizer_initialized = True\n\n if self._preload_opt_states is not None:\n self.load_optimizer_states(self._preload_opt_states)\n self._preload_opt_states = None","def load_checkpoint(self, checkpoint_path=None):\n if checkpoint_path is None:\n checkpoint_path = self.get_latest_path()\n\n if os.path.isfile(checkpoint_path):\n key = 'cuda' if torch.cuda.is_available() else 'cpu'\n checkpoint = torch.load(checkpoint_path, map_location=key)\n self.network.load_state_dict(checkpoint['network'])\n self.network_target.load_state_dict(checkpoint['network_target'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n print('checkpoint loaded at {}'.format(checkpoint_path))\n else:\n raise OSError(\"Checkpoint file not found.\")","def create_orttrainer_and_save_checkpoint_bart(device, trainer_opts, checkpoint_dir, state_dict_key_name='state_dict', use_lamb=True, seed=1, learning_rate=0.1):\n torch.manual_seed(seed)\n set_seed(seed)\n\n ort_trainer_opts = orttrainer.ORTTrainerOptions(trainer_opts)\n optim_config = optim.LambConfig(lr=learning_rate) if use_lamb else optim.AdamConfig(lr=learning_rate)\n model, model_desc = _load_bart_model()\n trainer = orttrainer.ORTTrainer(model, model_desc, optim_config, options=ort_trainer_opts)\n\n # load dummy optimizer state as we are not going to run real training\n dummy_init_state = generate_dummy_optim_state(model, optim_config)\n init_state = copy.deepcopy(dummy_init_state)\n trainer.load_state_dict(dummy_init_state)\n\n # run an eval step to innitialize the graph\n src_tokens, prev_output_tokens, target = generate_random_input_from_bart_model_desc(model_desc, seed = seed)\n trainer.eval_step(src_tokens, prev_output_tokens, target)\n\n # save current model parameters as a checkpoint\n if checkpoint_dir:\n if _is_model_parallel_run(ort_trainer_opts):\n _save(trainer, checkpoint_dir, state_dict_key_name, world_rank=ort_trainer_opts.distributed.world_rank)\n # save the initial complete model and optimizer states\n if ort_trainer_opts.distributed.world_rank == 0:\n init_state['model'] = {'full_precision': dict()}\n for initializer in model.graph.initializer:\n init_state['model']['full_precision'][initializer.name] = numpy_helper.to_array(initializer)\n with open(os.path.join(checkpoint_dir, 'expected_state_dict.pkl'), \"wb\") as f:\n pickle.dump(init_state, f)\n else:\n _save(trainer, checkpoint_dir, state_dict_key_name)","def load_checkpoint(self, checkpoint: str, **kwargs) -> None:\n with open(checkpoint, \"rb\") as f:\n state = SafePickle.load(f)\n\n state_id = ray.put(state)\n ray.get([worker.set_state.remote(state_id, **kwargs) for worker in self.remote_workers])","def load_model(self, checkpoint):\n print(f'Load parameters from {checkpoint}')\n epoch = re.match(r\"[0-9]*\", os.path.basename(checkpoint)).group(0)\n self.epoch_i = int(epoch)\n self.model.load_state_dict(torch.load(checkpoint))","def unpack_checkpoint(\n self,\n checkpoint: Dict,\n model=None,\n criterion=None,\n optimizer=None,\n scheduler=None,\n **kwargs,\n ) -> None:\n super().unpack_checkpoint(\n checkpoint,\n model=model,\n criterion=criterion,\n optimizer=optimizer,\n scheduler=scheduler,\n **kwargs,\n )\n\n # NOTE: propper way to load state, docs:\n # https://nvidia.github.io/apex/amp.html#checkpointing\n if \"amp\" in checkpoint:\n amp.load_state_dict(checkpoint[\"amp\"])","def unpack_checkpoint(\n self,\n checkpoint: Dict,\n model=None,\n criterion=None,\n optimizer=None,\n scheduler=None,\n **kwargs,\n ) -> None:\n super().unpack_checkpoint(\n checkpoint,\n model=model,\n criterion=criterion,\n optimizer=optimizer,\n scheduler=scheduler,\n **kwargs,\n )\n\n # NOTE: propper way to load state, docs:\n # https://nvidia.github.io/apex/amp.html#checkpointing\n if \"amp\" in checkpoint:\n amp.load_state_dict(checkpoint[\"amp\"])","def load(loadname, checkpoint=None):\n ckpt_dir = \"./models/tf_ckpt_\" + loadname + \"/\"\n if checkpoint is not None:\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\n status.assert_consumed()\n print(\"Loaded checkpoint\")\n else:\n print(\"Not Loading any checkpoint\")\n print(\"Starting training from initial configuration\")","def load_optimizers(self, epoch):\n for i, optimizer in enumerate(self.optimizers):\n load_filename = '{0}_optimizer_{1}.pth'.format(epoch, i)\n load_path = os.path.join(self.save_dir, load_filename)\n print('loading the optimizer from {0}'.format(load_path))\n state_dict = torch.load(load_path)\n if hasattr(state_dict, '_metadata'):\n del state_dict._metadata\n optimizer.load_state_dict(state_dict)","def train(self, num_epochs, state_transition_model, save_weights_path='./stored_data/weights/policy_network/policy_network',\n load_weights=False, load_weights_path=None):\n with self.sess as sess: \n stm_weights_path = ('./stored_data/weights/state_transition_model/state_transition_model_'\n + self.energy_system.electricity_pricing_model + '.h5')\n state_transition_model.load_weights(stm_weights_path)\n\n starting_state = tf.placeholder(tf.float32, shape=(None, self.num_state_variables), name='starting_state')\n normalized_starting_state_vals = self._get_normalized_starting_state_values_and_set_battery_soc()\n print(\"\\nNow creating computational graph\")\n print(\"Available memory in GB:\", psutil.virtual_memory().available / 1000000000.0)\n average_reward_per_rollout_op, average_electricity_cost_per_rollout_op = self.simulate_epoch(starting_state, state_transition_model)\n print(\"\\nNow creating optimizer op\")\n print(\"Available memory in GB:\", psutil.virtual_memory().available / 1000000000.0)\n train_op = tf.train.AdamOptimizer().minimize(-average_reward_per_rollout_op, \n var_list=[self.model.trainable_variables],\n name='policy_optimizer')\n print(\"\\nNow merging sumaries\")\n print(\"Available memory in GB:\", psutil.virtual_memory().available / 1000000000.0)\n merged_tensorboard_summary = tf.summary.merge_all()\n writer = tf.summary.FileWriter('./stored_data/Tensorboard/policy_network/' + self.energy_system.electricity_pricing_model + '/')\n #writer.add_graph(sess.graph)\n\n print(\"\\nNow initializing variables\")\n print(\"Available memory in GB:\", psutil.virtual_memory().available / 1000000000.0)\n self._initialize_local_and_global_variables()\n self.training_average_electricity_cost_in_euros = np.zeros(num_epochs)\n self.training_average_reward = np.zeros(num_epochs)\n\n if load_weights:\n self.load_weights(load_weights_path)\n\n feed_dict = {starting_state: normalized_starting_state_vals}\n print(\"\\nNow running first epoch\")\n print(\"Available memory in GB:\", psutil.virtual_memory().available / 1000000000.0)\n for epoch in range(num_epochs):\n op_list = [train_op, average_reward_per_rollout_op, average_electricity_cost_per_rollout_op, merged_tensorboard_summary]\n _, epoch_average_reward, epoch_average_electricity_cost, epoch_summary = sess.run(op_list, feed_dict=feed_dict)\n self.training_average_electricity_cost_in_euros[epoch] = epoch_average_electricity_cost\n self.training_average_reward[epoch] = epoch_average_reward\n if epoch % 10 == 0 or epoch == num_epochs-1:\n writer.add_summary(epoch_summary, epoch)\n print(\"Finished \" + str(epoch+1) + \" epochs out of \" + str(num_epochs)\n + \". Electricity cost: %.3f euros\" % epoch_average_electricity_cost)\n if epoch >= 99 and (epoch + 1) % 50 == 0:\n self.model.save_weights(save_weights_path + '_'\n + self.energy_system.electricity_pricing_model + '_'\n + str(epoch + 1)\n + '.h5')\n\n if num_epochs > 0:\n self.save_weights_and_monitoring_data(save_weights_path)\n\n self.plot_progress()","def load_checkpoint(path):\n\n # Get the model name\n model_name = path.split('-')[0]\n assert (model_name in ['vgg16', 'resnet50'\n ]), \"Path must have the correct model name\"\n\n # Load in checkpoint\n checkpoint = torch.load(path)\n\n if model_name == 'vgg16':\n model = models.vgg16(pretrained=True)\n # Make sure to set parameters as not trainable\n for param in model.parameters():\n param.requires_grad = False\n model.classifier = checkpoint['classifier']\n\n elif model_name == 'resnet50':\n model = models.resnet50(pretrained=True)\n # Make sure to set parameters as not trainable\n for param in model.parameters():\n param.requires_grad = False\n model.fc = checkpoint['fc']\n\n # Load in the state dict\n model.load_state_dict(checkpoint['state_dict'])\n\n total_params = sum(p.numel() for p in model.parameters())\n print(f'{total_params:,} total parameters.')\n total_trainable_params = sum(\n p.numel() for p in model.parameters() if p.requires_grad)\n print(f'{total_trainable_params:,} total gradient parameters.')\n\n # Move to gpu\n if multi_gpu:\n model = nn.DataParallel(model)\n\n if train_on_gpu:\n model = model.to('cuda')\n\n # Model basics\n model.class_to_idx = checkpoint['class_to_idx']\n model.idx_to_class = checkpoint['idx_to_class']\n model.epochs = checkpoint['epochs']\n\n # Optimizer\n optimizer = checkpoint['optimizer']\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n\n return model, optimizer","def train(config, alg, checkpoint=None):\n agent = get_agent_class(alg)(config=config, env=\"retro-v0\")\n if checkpoint is not None:\n try:\n agent.restore(checkpoint)\n print(f\"Resumed checkpoint {checkpoint}\")\n except:\n print(\"Checkpoint not found: restarted policy network from scratch\")\n else:\n print(\"Started policy network from scratch\")\n\n for i in range(1000000):\n # Perform one iteration of training the policy with the algorithm\n result = agent.train()\n print(pretty_print(result))\n\n if i % 50 == 0:\n checkpoint = agent.save()\n print(\"checkpoint saved at\", checkpoint)","def load_checkpoint_train(cpdir, model, optimizer):\n start_epoch = 0\n start_global_step = 0\n if cpdir is not None:\n start_global_step, start_epoch = load_checkpoint(\n cpdir, model, optimizer)\n start_global_step += 1\n start_epoch += 1\n return start_global_step, start_epoch","def reload_checkpoint(self):\n checkpoint_path = os.path.join(self.params.dump_path, 'checkpoint.pth')\n if not os.path.isfile(checkpoint_path):\n if self.params.reload_checkpoint == '':\n return\n else:\n checkpoint_path = self.params.reload_checkpoint\n assert os.path.isfile(checkpoint_path)\n logger.warning(\"Reloading checkpoint from %s ...\" % checkpoint_path)\n data = torch.load(checkpoint_path, map_location='cpu')\n\n # reload model parameters\n for name in self.MODEL_NAMES:\n getattr(self, name).load_state_dict(data[name])\n\n # reload optimizers\n for name in self.optimizers.keys():\n if False: # AMP checkpoint reloading is buggy, we cannot do that - TODO: fix - https://github.com/NVIDIA/apex/issues/250\n logger.warning(\"Reloading checkpoint optimizer %s ...\" % name)\n else: # instead, we only reload current iterations / learning rates\n logger.warning(\"Not reloading checkpoint optimizer %s.\" % name)\n for group_id, param_group in enumerate(self.optimizers[name].param_groups):\n if 'num_updates' not in param_group:\n logger.warning(\"No 'num_updates' for optimizer %s.\" % name)\n continue\n logger.warning(\"Reloading 'num_updates' and 'lr' for optimizer %s.\" % name)\n param_group['num_updates'] = data['%s_optimizer' % name]['param_groups'][group_id]['num_updates']\n param_group['lr'] = self.optimizers[name].get_lr_for_step(param_group['num_updates'])\n\n # reload main metrics\n self.epoch = data['epoch'] + 1\n self.n_total_iter = data['n_total_iter']\n self.best_metrics = data['best_metrics']\n self.best_stopping_criterion = data['best_stopping_criterion']\n logger.warning(\"Checkpoint reloaded. Resuming at epoch %i / iteration %i ...\" % (self.epoch, self.n_total_iter))","def _restore_checkpoint(self, checkpoint_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(checkpoint_path))\n checkpoint = torch.load(checkpoint_path)\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\n \n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\n print('Parameters are inconsistant, adapting model parameters ...')\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\n del pretrained_dict['1']\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\n self.model.load_state_dict(model_dict)\n else:\n print('Parameters are consistant, load state dict directly ...')\n self.model.load_state_dict(checkpoint['state_dict'])\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\n # if self.with_cuda:\n # for state in self.optimizer.state.values():\n # for k, v in state.items():\n # if isinstance(v, torch.Tensor):\n # state[k] = v.cuda(self.device)","def create_or_load_model(model, model_dir, session, name):\n latest_ckpt = tf.train.latest_checkpoint(model_dir)\n if latest_ckpt:\n start_time = time.time()\n # It only takes a few seconds to initialize all variables.\n session.run(tf.global_variables_initializer())\n logging.info(\n \"Initialize %s model with fresh parameters before loading variables \"\n \"from the checkpoint, time %.2fs\", name,\n time.time() - start_time)\n model = load_model(model, latest_ckpt, session, name)\n else:\n start_time = time.time()\n session.run(tf.global_variables_initializer())\n session.run(tf.tables_initializer())\n utils.print_out(\" created %s model with fresh parameters, time %.2fs\" %\n (name, time.time() - start_time))\n\n global_step = model.global_step.eval(session=session)\n return model, global_step","def load_states(self, checkpoint):\n raise NotImplementedError()","def from_checkpoint(\n checkpoint: Union[str, Checkpoint],\n policy_ids: Optional[Container[PolicyID]] = None,\n policy_mapping_fn: Optional[Callable[[AgentID, EpisodeID], PolicyID]] = None,\n policies_to_train: Optional[\n Union[\n Container[PolicyID],\n Callable[[PolicyID, Optional[SampleBatchType]], bool],\n ]\n ] = None,\n ) -> \"Algorithm\":\n checkpoint_info = get_checkpoint_info(checkpoint)\n\n # Not possible for (v0.1) (algo class and config information missing\n # or very hard to retrieve).\n if checkpoint_info[\"checkpoint_version\"] == version.Version(\"0.1\"):\n raise ValueError(\n \"Cannot restore a v0 checkpoint using `Algorithm.from_checkpoint()`!\"\n \"In this case, do the following:\\n\"\n \"1) Create a new Algorithm object using your original config.\\n\"\n \"2) Call the `restore()` method of this algo object passing it\"\n \" your checkpoint dir or AIR Checkpoint object.\"\n )\n elif checkpoint_info[\"checkpoint_version\"] < version.Version(\"1.0\"):\n raise ValueError(\n \"`checkpoint_info['checkpoint_version']` in `Algorithm.from_checkpoint\"\n \"()` must be 1.0 or later! You are using a checkpoint with \"\n f\"version v{checkpoint_info['checkpoint_version']}.\"\n )\n\n # This is a msgpack checkpoint.\n if checkpoint_info[\"format\"] == \"msgpack\":\n # User did not provide unserializable function with this call\n # (`policy_mapping_fn`). Note that if `policies_to_train` is None, it\n # defaults to training all policies (so it's ok to not provide this here).\n if policy_mapping_fn is None:\n # Only DEFAULT_POLICY_ID present in this algorithm, provide default\n # implementations of these two functions.\n if checkpoint_info[\"policy_ids\"] == {DEFAULT_POLICY_ID}:\n policy_mapping_fn = AlgorithmConfig.DEFAULT_POLICY_MAPPING_FN\n # Provide meaningful error message.\n else:\n raise ValueError(\n \"You are trying to restore a multi-agent algorithm from a \"\n \"`msgpack` formatted checkpoint, which do NOT store the \"\n \"`policy_mapping_fn` or `policies_to_train` \"\n \"functions! Make sure that when using the \"\n \"`Algorithm.from_checkpoint()` utility, you also pass the \"\n \"args: `policy_mapping_fn` and `policies_to_train` with your \"\n \"call. You might leave `policies_to_train=None` in case \"\n \"you would like to train all policies anyways.\"\n )\n\n state = Algorithm._checkpoint_info_to_algorithm_state(\n checkpoint_info=checkpoint_info,\n policy_ids=policy_ids,\n policy_mapping_fn=policy_mapping_fn,\n policies_to_train=policies_to_train,\n )\n\n return Algorithm.from_state(state)","def create_train_state(\n config, rng, learning_rate_fn, example_batch\n):\n model, variables, metric_collector = create_model(config, rng, example_batch)\n params = variables['params']\n parameter_overview.log_parameter_overview(params)\n tx = train_utils.create_optimizer(config, learning_rate_fn)\n\n state = train_state.TrainState.create(\n apply_fn=model.apply,\n params=variables['params'],\n tx=tx,\n )\n return model, state, metric_collector","def load_checkpoint(ckpt_path):\n checkpoint = None\n if ckpt_path:\n logger.info(\"Loading checkpoint from %s\" % ckpt_path)\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\"cpu\"))\n\n if \"model\" in checkpoint.keys():\n # This preserves backward-compat for models using customed layernorm\n def fix_key(s):\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.b_2\", r\"\\1.layer_norm\\2.bias\", s\n )\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.a_2\", r\"\\1.layer_norm\\2.weight\", s\n )\n return s\n\n checkpoint[\"model\"] = {\n fix_key(k): v for k, v in checkpoint[\"model\"].items()\n }\n # Force add_ffnbias to True if bias found in model w_1 keys\n for key in checkpoint[\"model\"].keys():\n if \"w_1.bias\" in key:\n checkpoint[\"opt\"].add_ffnbias = True\n\n if not hasattr(checkpoint[\"opt\"], \"num_kv\"):\n checkpoint[\"opt\"].num_kv = 0\n if not hasattr(checkpoint[\"opt\"], \"add_ffnbias\"):\n checkpoint[\"opt\"].add_ffnbias = False\n if not hasattr(checkpoint[\"opt\"], \"parallel_residual\"):\n checkpoint[\"opt\"].parallel_residual = False\n if not hasattr(checkpoint[\"opt\"], \"shared_layer_norm\"):\n checkpoint[\"opt\"].shared_layer_norm = False\n if not hasattr(checkpoint[\"opt\"], \"use_ckpting\"):\n checkpoint[\"opt\"].use_ckpting = []\n if not hasattr(checkpoint[\"opt\"], \"relative_positions_buckets\"):\n checkpoint[\"opt\"].relative_positions_buckets = 0\n if not hasattr(checkpoint[\"opt\"], \"parallel_mode\"):\n checkpoint[\"opt\"].parallel_mode = \"data_parallel\"\n if not hasattr(checkpoint[\"opt\"], \"norm_eps\"):\n checkpoint[\"opt\"].norm_eps = 1e-6\n\n # fix v2 compatibility\n if \"generator\" in checkpoint.keys() and checkpoint[\"generator\"]:\n if \"0.weight\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"weight\"] = checkpoint[\"generator\"].pop(\n \"0.weight\"\n )\n if \"0.bias\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"bias\"] = checkpoint[\"generator\"].pop(\"0.bias\")\n # end of patch for backward compatibility\n\n return checkpoint","def load(self):\r\n checkpoint = torch.load(self.checkpoint_path,\r\n map_location=self.device)\r\n self.load_state_dict(checkpoint)\r\n del checkpoint","def initialize_optimization(self):\n\n if self.FLAGS.optimizer == \"Adam\" :\n self.solver = tf.train.AdamOptimizer(\n learning_rate = self.learning_rate,\n beta1 = self.FLAGS.beta1,\n beta2 = self.FLAGS.beta2)\n else:\n print(\"ERROR: Cannot handle optimizer type {}!!!\".format(self.FLAGS.optimizer))\n raise RuntimeError\n \n # batch normalization in tensorflow requires this extra dependency\n # this is required to update the moving mean and moving variance variables\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n with tf.control_dependencies(extra_update_ops):\n self.update = self.solver.minimize(self.loss, global_step=self.global_step)","def importOptimizer():\n module_path = os.path.join(path, \"optimization\")\n module_path = os.path.join(module_path, \"optimizer.py\")\n optimizer_class = importClass(\"Optimizer\", \"optimizer\", module_path)\n return optimizer_class","def create_orttrainer_and_load_checkpoint(device, trainer_opts, checkpoint_dir, use_lamb=True, seed=1, learning_rate=0.1):\n torch.manual_seed(seed)\n set_seed(seed)\n\n # PyTorch transformer model setup \n optim_config = optim.LambConfig(lr=learning_rate) if use_lamb else optim.AdamConfig(lr=learning_rate)\n model, model_desc, loss_fn, batcher_fn, train_data, _, _ = _load_pytorch_transformer_model(device)\n trainer = orttrainer.ORTTrainer(model, model_desc, optim_config, loss_fn=loss_fn, options=orttrainer.ORTTrainerOptions(trainer_opts))\n\n # load checkpoint into trainer\n checkpoint_file_name = 'checkpoint*.ortcp'\n checkpoint_files = glob.glob(os.path.join(checkpoint_dir, checkpoint_file_name))\n trainer.load_checkpoint(*checkpoint_files)\n\n # run an eval step to innitialize the graph\n torch.manual_seed(seed)\n set_seed(seed)\n data, targets = batcher_fn(train_data, 0)\n trainer.eval_step(data, targets)\n\n return trainer.state_dict(), model","def _get_init_fn():\n exclusions = []\n if FLAGS.checkpoint_exclude_scopes:\n exclusions = [scope.strip()\n for scope in FLAGS.checkpoint_exclude_scopes.split(',')]\n\n variables_to_restore = []\n for var in slim.get_model_variables():\n excluded = False\n for exclusion in exclusions:\n if var.op.name.startswith(exclusion):\n excluded = True\n break\n if not excluded:\n variables_to_restore.append(var)\n\n if tf.gfile.IsDirectory(FLAGS.checkpoint_path):\n checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)\n else:\n checkpoint_path = FLAGS.checkpoint_path\n\n tf.logging.info('Fine-tuning from {}'.format(checkpoint_path))\n\n return slim.assign_from_checkpoint_fn(checkpoint_path, variables_to_restore)","def optimizer_factory(config, model):\n params = model.parameters()\n\n optimizer = config[\"loss\"].get(\"optimizer\", \"Adam\")\n lr = config[\"loss\"].get(\"lr\", 1e-3)\n momentum = config[\"loss\"].get(\"momentum\", 0.9)\n\n if optimizer == \"SGD\":\n return optim.SGD(params, lr=lr, momentum=momentum)\n elif optimizer == \"Adam\":\n return optim.Adam(params, lr=lr)\n else:\n raise NotImplementedError()","def load(self):\n checkpoint = torch.load(self.checkpoint_path,\n map_location=self.net.device)\n self.load_state_dict(checkpoint)\n del checkpoint","def load(self, checkpoint_dir=None):\n\n if checkpoint_dir is None:\n checkpoint_dir = FLAGS.checkpoint_dir\n\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n\n return self.load_from_path(checkpoint_dir)","def _inst_optimizer(self):\n optimizer = Optimizers(self.m_cfg['configs']['lr_politics']['optimizer']).value\n lr_schedule = self.m_cfg['configs']['lr_politics']['lr']\n opt = optimizer(learning_rate=lr_schedule)\n return opt","def build_optimizer(optimizer_config, params, name=None):\n\n if optimizer_config.name == 'rms_prop_optimizer':\n\n optimizer = paddle.optimizer.RMSProp(\n parameters = params,\n learning_rate=_get_base_lr_by_lr_scheduler(optimizer_config.learning_rate),\n rho=optimizer_config.decay,\n momentum=optimizer_config.momentum_optimizer_value,\n epsilon=optimizer_config.epsilon,\n weight_decay=optimizer_config.weight_decay)\n\n if optimizer_config.name =='momentum_optimizer':\n\n optimizer = paddle.optimizer.SGD(\n parameters = params,\n learning_rate=_get_base_lr_by_lr_scheduler(optimizer_config.learning_rate),\n weight_decay=optimizer_config.weight_decay)\n\n if optimizer_config.name =='adam_optimizer':\n\n optimizer = paddle.optimizer.Adam(\n parameters = params,\n learning_rate=_get_base_lr_by_lr_scheduler(optimizer_config.learning_rate),\n weight_decay=optimizer_config.weight_decay)\n\n if optimizer is None:\n raise ValueError('Optimizer %s not supported.' % optimizer_config.name)\n\n if optimizer_config.use_moving_average:\n raise ValueError('paddle don\\'t support moving average')\n if name is None:\n # assign a name to optimizer for checkpoint system\n optimizer.name = optimizer_config.name\n else:\n optimizer.name = name\n return optimizer","def load_G(self, G_checkpoint):\n checkpoint = torch.load(G_checkpoint)\n self.G.load_state_dict(checkpoint['gnet'])\n self.gen_optim.load_state_dict(checkpoint['gopt'])","def load_sharded_optimizer(self, optimizer: Optimizer, index_file_path: str, size_per_shard: int):\n raise NotImplementedError(\"Sharded optimizer checkpoint is not supported yet.\")","def create_optimizer(optimizer_name, model, config):\n if optimizer_name == 'adadelta':\n return torch.optim.Adadelta(model.parameters(),\n lr=config['adadelta_lr'],\n rho=config['adadelta_rho'],\n weight_decay=config['adadelta_weight_decay'],\n eps=config['adadelta_eps'])\n else:\n raise Exception('Optimizer \\'{}\\' not supported.'.format(optimizer_name))","def create_orttrainer_and_load_checkpoint_bart(device, trainer_opts, checkpoint_dir, use_lamb=True, seed=1, learning_rate=0.1):\n torch.manual_seed(seed)\n set_seed(seed)\n\n # model setup\n optim_config = optim.LambConfig(lr=learning_rate) if use_lamb else optim.AdamConfig(lr=learning_rate)\n model, model_desc = _load_bart_model()\n trainer = orttrainer.ORTTrainer(model, model_desc, optim_config, options=orttrainer.ORTTrainerOptions(trainer_opts))\n\n # load checkpoint into trainer\n checkpoint_file_name = 'checkpoint*.ortcp'\n checkpoint_files = glob.glob(os.path.join(checkpoint_dir, checkpoint_file_name))\n trainer.load_checkpoint(*checkpoint_files)\n\n # run an eval step to innitialize the graph\n src_tokens, prev_output_tokens, target = generate_random_input_from_bart_model_desc(model_desc, seed = seed)\n trainer.eval_step(src_tokens, prev_output_tokens, target)\n\n expected_state_dict = None\n fname = os.path.join(checkpoint_dir, 'expected_state_dict.pkl')\n if os.path.isfile(fname):\n with open(fname, \"rb\") as f:\n expected_state_dict = pickle.load(f)\n\n return trainer.state_dict(), expected_state_dict, model","def optimizer_setup(model, params):\n if params.optimizer == 'adam':\n if params.freeze_backbone:\n optimizer = optimizer_handler.layer_specific_adam(model, params)\n else:\n optimizer = optimizer_handler.plain_adam(model, params)\n elif params.optimizer == 'sgd':\n if params.freeze_backbone:\n optimizer = optimizer_handler.layer_specific_sgd(model, params)\n else:\n optimizer = optimizer_handler.plain_sgd(model, params)\n\n if params.zero_bn_bias_decay:\n optimizer = zero_wdcay_bn_bias(optimizer)\n\n return optimizer","def init_optimizer(self, state_dict=None, use_gpu=True):\n if self.args.fix_embeddings:\n self.network.embedder.src_word_embeddings.fix_word_lut()\n self.network.embedder.tgt_word_embeddings.fix_word_lut()\n\n if self.args.optimizer == 'sgd':\n parameters = [p for p in self.network.parameters() if p.requires_grad]\n self.optimizer = optim.SGD(parameters,\n self.args.learning_rate,\n momentum=self.args.momentum,\n weight_decay=self.args.weight_decay)\n\n elif self.args.optimizer == 'adam':\n parameters = [p for p in self.network.parameters() if p.requires_grad]\n self.optimizer = optim.Adam(parameters,\n self.args.learning_rate,\n weight_decay=self.args.weight_decay)\n elif self.args.optimizer == 'adamW':\n parameters = [p for p in self.network.parameters() if p.requires_grad]\n self.optimizer = optim.AdamW(parameters,\n self.args.learning_rate,\n weight_decay=self.args.weight_decay)\n\n else:\n raise RuntimeError('Unsupported optimizer: %s' % self.args.optimizer)\n\n if state_dict is not None:\n self.optimizer.load_state_dict(state_dict)\n # FIXME: temp soln - https://github.com/pytorch/pytorch/issues/2830\n if use_gpu:\n for state in self.optimizer.state.values():\n for k, v in state.items():\n if torch.is_tensor(v):\n state[k] = v.cuda()","def load_model(self, ckpt_fn):\n checkpoint = torch.load(ckpt_fn)\n self.net_.load_state_dict(checkpoint[\"model\"])\n self.optimizer_.load_state_dict(checkpoint[\"optimizer\"])\n self.epoch_ = checkpoint[\"epoch\"]\n self.global_step_ = checkpoint[\"global_step\"]\n self.model_samples_ = deque(checkpoint[\"model_samples\"])\n self.sampler.load_state_dict(checkpoint[\"sampler_state\"])\n self.ais_loss.load_state_dict(checkpoint[\"ais_state\"])\n self.replay_prob = checkpoint[\"replay_prob\"]\n self.max_replay = checkpoint[\"max_replay\"]","def load_D( self, D_checkpoint):\n checkpoint = torch.load(D_checkpoint)\n self.D.load_state_dict(checkpoint['dnet'])\n self.dis_optim.load_state_dict(checkpoint['gopt'])","def _create_train_op(self):\n self.lr = self.learning_rate\n # global_step = tf.train.get_or_create_global_step()\n learning_rate = tf.constant(value=self.learning_rate, shape=[], dtype=tf.float32)\n learning_rate =tf.train.exponential_decay(learning_rate,self.global_step,2*self.num_warm_up,0.96,staircase=True,name=\"exponential_decay\")\n\n # Implements linear warmup. I.e., if global_step < num_warmup_steps, the\n # learning rate will be `global_step/num_warmup_steps * init_lr`.\n if self.num_warm_up:\n global_steps_int = tf.cast(self.global_step, tf.int32)\n warmup_steps_int = tf.constant(self.num_warm_up, dtype=tf.int32)\n\n global_steps_float = tf.cast(global_steps_int, tf.float32)\n warmup_steps_float = tf.cast(warmup_steps_int, tf.float32)\n\n warmup_percent_done = global_steps_float / warmup_steps_float\n warmup_learning_rate = self.learning_rate * warmup_percent_done\n\n is_warmup = tf.cast(global_steps_int < warmup_steps_int, tf.float32)\n learning_rate = (\n (1.0 - is_warmup) * learning_rate + is_warmup * warmup_learning_rate)\n self.current_learning_rate = learning_rate\n if self.optim_type == 'adagrad':\n self.optimizer = tf.train.AdagradOptimizer(self.lr)\n elif self.optim_type == 'adam':\n self.optimizer = tf.train.AdamOptimizer(learning_rate=self.lr)\n elif self.optim_type == 'rprop':\n self.optimizer = tf.train.RMSPropOptimizer(self.lr)\n elif self.optim_type == 'sgd':\n self.optimizer = tf.train.GradientDescentOptimizer(self.lr)\n elif self.optim_type == \"bert\":\n self.optimizer = AdamWeightDecayOptimizer(learning_rate=learning_rate, weight_decay_rate=0.01, beta_1=0.9,\n beta_2=0.999, epsilon=1e-6,\n exclude_from_weight_decay=[\"LayerNorm\", \"layer_norm\", \"bias\"])\n else:\n raise NotImplementedError('Unsupported optimizer: {}'.format(self.optim_type))\n\n self.logger.info(\"applying optimize %s\" % self.optim_type)\n if self.clip_weight:\n # clip_weight\n tvars = tf.trainable_variables()\n grads = tf.gradients(self.loss, tvars)\n grads, _ = tf.clip_by_global_norm(grads, clip_norm=self.max_norm_grad)\n grad_var_pairs = zip(grads, tvars)\n train_op = self.optimizer.apply_gradients(grad_var_pairs, name='apply_grad', global_step=self.global_step)\n new_global_step = self.global_step + 1\n train_op = tf.group(train_op, [self.global_step.assign(new_global_step)])\n self.train_op = train_op\n else:\n self.train_op = self.optimizer.minimize(self.loss, global_step=self.global_step)","def from_checkpoints(\n self,\n restore_cfgs: Sequence[RestoreCheckpointConfig],\n ds_iter: Optional[tf.data.Iterator] = None,\n init_rng: Optional[jnp.ndarray] = None,\n ) -> Iterator[train_state_lib.TrainState]:\n\n def _restore_path(path, cfg):\n restore_checkpointer = cfg.checkpointer_cls(\n train_state=self.global_train_state_shape,\n partitioner=self._partitioner,\n checkpoints_dir='', # unused for restore\n dataset_iterator=ds_iter if cfg.restore_dataset else None,\n restore_dtype=jnp.dtype(cfg.dtype) if cfg.dtype else None)\n\n from_tensorflow = gfile.exists(path + '.index')\n if from_tensorflow and cfg.state_transformation_fns:\n raise ValueError('Cannot initialize from a TensorFlow checkpoint using '\n '`state_transformation_fns`.')\n if from_tensorflow:\n logging.info('Initializing parameters from TensorFlow checkpoint %s',\n path)\n return restore_checkpointer.restore_from_tf_checkpoint(\n path, strict=cfg.strict)\n\n else:\n if cfg.fallback_to_scratch:\n if not cfg.state_transformation_fns:\n raise ValueError('`state_transformation_fns` must be provided with '\n '`fallback_to_scratch`')\n if init_rng is None:\n raise ValueError('An `init_rng` must be provided with '\n '`fallback_to_scratch`')\n fallback_state = self.from_scratch(init_rng).state_dict()\n else:\n fallback_state = None\n\n logging.info('Initializing parameters from specific T5X checkpoint %s',\n path)\n return restore_checkpointer.restore(\n path=path,\n state_transformation_fns=cfg.state_transformation_fns,\n fallback_state=fallback_state)\n\n for restore_cfg in restore_cfgs:\n paths = ([restore_cfg.path]\n if isinstance(restore_cfg.path, str) else restore_cfg.path)\n if restore_cfg.mode == 'specific':\n logging.info('Restoring specific checkpoint(s): %s', paths)\n for path in paths:\n yield _restore_path(path, restore_cfg)\n return\n elif restore_cfg.mode in ('all', 'latest'):\n for ckpt_dir in paths:\n if not gfile.isdir(ckpt_dir):\n raise ValueError(\n 'Checkpoint path(s) must be valid directories when using '\n \"restore mode 'all' or 'latest'.\")\n # Check if this is a TensorFlow checkpoint dir.\n tf_ckpt_state = tf.train.get_checkpoint_state(ckpt_dir)\n\n if tf_ckpt_state:\n ckpt_paths = tf_ckpt_state.all_model_checkpoint_paths\n else:\n ckpt_paths = [\n os.path.join(ckpt_dir, f'checkpoint_{step}')\n for step in checkpoints.all_steps(ckpt_dir)\n ]\n if not ckpt_paths:\n logging.info('No checkpoints found in specified directory: %s',\n ckpt_dir)\n continue\n if restore_cfg.mode == 'latest':\n logging.info('Restoring latest T5X checkpoint.')\n ckpt_paths = ckpt_paths[-1:]\n logging.info('Restoring checkpoints for path(s): %s', ckpt_paths)\n for ckpt_path in ckpt_paths:\n yield _restore_path(ckpt_path, restore_cfg)\n return\n else:\n raise ValueError(\n f'Unsupported checkpoint restore mode: {restore_cfg.mode}')","def load_from_path(self, checkpoint_dir):\n\n vars = self.save_var_names\n saver = tf.train.Saver(vars)\n\n def load_aux(ckpt_path):\n \"\"\"Helper function to not repeat the same code in the following lines.\"\"\"\n\n ckpt_name = os.path.basename(ckpt_path)\n saver.restore(self.sess, ckpt_path)\n counter = int(next(re.finditer(\"(\\d+)(?!.*\\d)\", ckpt_name)).group(0))\n self.counter = counter\n print(\" [*] Loaded {}\".format(ckpt_name))\n return True, counter\n\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\n try:\n if ckpt and ckpt.model_checkpoint_path:\n ckpt_name = os.path.basename(ckpt.model_checkpoint_path)\n return load_aux(os.path.join(checkpoint_dir, ckpt_name))\n else:\n print(\n \" [!] Failed to find a checkpoint within directory {}\".format(\n FLAGS.ckpt_path))\n return False, 0\n except:\n print(\" [!] Failed to find a checkpoint, Exception!\")\n return False, 0","def define_model_and_optimizer(self):\r\n print(\"* Defining model and optimizer.\", flush=True)\r\n job_dir = self.C.job_dir\r\n\r\n if self.C.restart:\r\n print(\"-- Loading model from previous saved state.\", flush=True)\r\n self.restart_epoch = util.get_restart_epoch()\r\n self.model = torch.load(f\"{job_dir}model_restart_{self.restart_epoch}.pth\")\r\n\r\n print(\r\n f\"-- Backing up as \"\r\n f\"{job_dir}model_restart_{self.restart_epoch}_restarted.pth.\",\r\n flush=True,\r\n )\r\n shutil.copyfile(\r\n f\"{job_dir}model_restart_{self.restart_epoch}.pth\",\r\n f\"{job_dir}model_restart_{self.restart_epoch}_restarted.pth\",\r\n )\r\n\r\n else:\r\n print(\"-- Initializing model from scratch.\", flush=True)\r\n self.model = models.initialize_model()\r\n\r\n self.restart_epoch = 0\r\n\r\n start_epoch = self.restart_epoch + 1\r\n end_epoch = start_epoch + self.C.epochs\r\n\r\n print(\"-- Defining optimizer.\", flush=True)\r\n self.optimizer = torch.optim.Adam(\r\n params=self.model.parameters(),\r\n lr=self.C.init_lr,\r\n weight_decay=self.C.weight_decay,\r\n )\r\n\r\n return start_epoch, end_epoch","def load_checkpoint(self, label):\n model_dir = os.path.join(\n config.results_dir, config.experiment_name, 'checkpoints')\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\n\n print(\"Loading model from {}\".format(model_file))\n model_dict = torch.load(model_file)\n\n self.use_cuda = model_dict['use_cuda']\n if self.use_cuda:\n self.net.cuda()\n\n self.net.load_state_dict(model_dict['net_state_dict'])","def load(cls, path):\n print(f'load checkpoint from {path}')\n if torch.cuda.is_available():\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\n else:\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\n \n # model.flatten_parameters() # make RNN parameters contiguous\n optimizer = resume_checkpoint['optimizer']\n return Checkpoint(\n model=model, \n optimizer=optimizer,\n epoch=resume_checkpoint['epoch'],\n path=path\n )","def load_checkpoint(self, checkpoint_dir):\r\n\r\n if not os.path.exists(checkpoint_dir):\r\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\r\n\r\n path = os.path.join(checkpoint_dir, 'model.pt')\r\n self.model.load_state_dict(torch.load(path, self.device))\r\n self.update()","def __init__(self, optimizer):\n super(ShardedOptimizer, self).__init__(optimizer, name=\"ShardedOptimizer\")","def load_checkpoint(self):\n checkpoin_path = self.get_checkpoint_path()\n _logger.info('Load checkpoint ignored by tuner, checkpoint path: %s', checkpoin_path)","def _init_model(self, checkpoint_path: str) -> None:\n # load weights\n logger.info(f\"Load weights from the checkpoint {checkpoint_path}\")\n checkpoint = torch.load(checkpoint_path, map_location=torch.device(\"cpu\"))\n\n state_dict = checkpoint[\"state_dict\"]\n self.orig_acc = checkpoint[\"test_acc\"]\n\n is_pruned = (\n next((name for name in state_dict if \"mask\" in name), None) is not None\n )\n\n if is_pruned:\n logger.info(\"Dummy prunning to load pruned weights\")\n model_utils.dummy_pruning(self.params_all)\n\n model_utils.initialize_params(self.model, state_dict)\n logger.info(\"Initialized weights\")\n\n # check the trained model is pruned\n\n if is_pruned:\n logger.info(\n \"Get masks and remove prunning reparameterization for prepare_qat\"\n )\n self.mask = model_utils.get_masks(self.model)\n model_utils.remove_pruning_reparameterization(self.params_all)","def create_optimizer(hparams):\n\n if hparams.optimizer == 'momentum':\n optimizer = tf.train.MomentumOptimizer(\n learning_rate=hparams.learning_rate, momentum=hparams.momentum)\n elif hparams.optimizer == 'adam':\n optimizer = tf.train.AdamOptimizer(\n learning_rate=hparams.learning_rate)\n elif hparams.optimizer == 'adadelta':\n optimizer = tf.train.AdadeltaOptimizer(\n hparams.learning_rate)\n elif hparams.optimizer == 'adagrad':\n optimizer = tf.train.AdagradOptimizer(\n hparams.learning_rate)\n elif hparams.optimizer == 'rmsprop':\n optimizer = tf.train.RMSPropOptimizer(\n hparams.learning_rate, momentum=hparams.momentum)\n\n return optimizer","def load_model (checkpoint_path, model, opt_fn=None, loss_fn=None, epoch=None):\n\n if not os.path.exists(checkpoint_path):\n raise Exception (\"The {} does not exist!\".format(checkpoint_path))\n\n ckpt = torch.load(checkpoint_path)\n model.load_state_dict(ckpt['model_state_dict'])\n\n if opt_fn is not None and loss_fn is not None:\n opt_fn.load_state_dict(ckpt['optimizer_state_dict'])\n epoch = ckpt['epoch']\n loss_fn = ckpt['loss']\n return model, opt_fn, loss_fn, epoch\n else:\n return model","def _get_init_fn():\n if FLAGS.checkpoint_path is None:\n return None\n\n # Warn the user if a checkpoint exists in the train_dir. Then we'll be\n # ignoring the checkpoint anyway.\n if tf.train.latest_checkpoint(FLAGS.train_dir):\n tf.logging.info(\n 'Ignoring --checkpoint_path because a checkpoint already exists in %s'\n % FLAGS.train_dir)\n return None\n\n exclusions = []\n if FLAGS.checkpoint_exclude_scopes:\n exclusions = [scope.strip()\n for scope in FLAGS.checkpoint_exclude_scopes.split(',')]\n\n # TODO(sguada) variables.filter_variables()\n variables_to_restore = []\n for var in slim.get_model_variables():\n excluded = False\n for exclusion in exclusions:\n if var.op.name.startswith(exclusion):\n excluded = True\n break\n if not excluded:\n variables_to_restore.append(var)\n\n if tf.gfile.IsDirectory(FLAGS.checkpoint_path):\n checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)\n else:\n checkpoint_path = FLAGS.checkpoint_path\n\n tf.logging.info('Fine-tuning from %s' % checkpoint_path)\n\n return slim.assign_from_checkpoint_fn(\n checkpoint_path,\n variables_to_restore,\n ignore_missing_vars=FLAGS.ignore_missing_vars)","def _get_init_fn():\n if FLAGS.checkpoint_path is None:\n return None\n\n # Warn the user if a checkpoint exists in the train_dir. Then we'll be\n # ignoring the checkpoint anyway.\n if tf.train.latest_checkpoint(FLAGS.train_dir):\n tf.logging.info(\n 'Ignoring --checkpoint_path because a checkpoint already exists in %s'\n % FLAGS.train_dir)\n return None\n\n exclusions = []\n if FLAGS.checkpoint_exclude_scopes:\n exclusions = [scope.strip()\n for scope in FLAGS.checkpoint_exclude_scopes.split(',')]\n\n # TODO(sguada) variables.filter_variables()\n variables_to_restore = []\n for var in slim.get_model_variables():\n excluded = False\n for exclusion in exclusions:\n if var.op.name.startswith(exclusion):\n excluded = True\n break\n if not excluded:\n variables_to_restore.append(var)\n\n if tf.gfile.IsDirectory(FLAGS.checkpoint_path):\n checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)\n else:\n checkpoint_path = FLAGS.checkpoint_path\n\n tf.logging.info('Fine-tuning from %s' % checkpoint_path)\n\n return slim.assign_from_checkpoint_fn(\n checkpoint_path,\n variables_to_restore,\n ignore_missing_vars=FLAGS.ignore_missing_vars)","def maybe_load_model(name, split_num, checkpoint_dir, resume_from_epoch,\n batch_norm, l1_factor, l2_factor, optimizer):\n basename = get_basename(name, split_num)\n model_filename_fmt = get_model_filename_fmt(basename)\n model_filename = model_filename_fmt.format(epoch=resume_from_epoch)\n\n checkpoint_path = os.path.join(checkpoint_dir, model_filename)\n\n if resume_from_epoch > 0 and os.path.isfile(checkpoint_path):\n\n click.secho(f\"Found model checkpoint '{checkpoint_path}'. \"\n f\"Resuming from epoch {resume_from_epoch}.\", fg='green')\n\n model = load_model(checkpoint_path)\n\n initial_epoch = resume_from_epoch\n\n else:\n\n click.secho(f\"Could not load model checkpoint '{checkpoint_path}' \"\n \"or `resume_from_epoch == 0`. Building new model.\",\n fg='yellow')\n\n model = build_model(output_dim=1, batch_norm=batch_norm,\n kernel_regularizer=l1_l2(l1_factor, l2_factor))\n # optimizer = Adam(beta_1=0.5)\n model.compile(loss='binary_crossentropy', optimizer=optimizer,\n metrics=['accuracy'])\n\n initial_epoch = 0\n\n return model, initial_epoch","def resume(model, optimizer, gpu, filepath='./saves/checkpoint.pth.tar'):\n assert isinstance(filepath, str)\n\n if gpu:\n f = torch.load(filepath)\n else:\n f = torch.load(filepath, map_location=lambda storage, loc: storage)\n epoch = f['epoch']\n losses = f['losses']\n seq_len = f['seq_len']\n\n model.load_state_dict(f['state_dict'])\n optimizer.load_state_dict(f['optimizer'])\n return model, optimizer, epoch, losses, seq_len","def load_from_checkpoint(results_dir, load_fn, args):\n ckpt_dir = os.path.join(results_dir, \"tb\", \"version_0\", \"checkpoints\")\n files = os.listdir(ckpt_dir)\n assert len(files) > 0, \"Checkpoint directory is empty\"\n ckpt_path = os.path.join(ckpt_dir, files[-1])\n model = load_fn(checkpoint_path=ckpt_path, args=args)\n return model","def init_optimizer(model, config, exact_layers=None):\n opt_type = config.optimizer\n if exact_layers:\n logger.info('Learning exact layers, number=%d', len(exact_layers))\n parameters = []\n for i, layer in enumerate(exact_layers):\n if isinstance(layer, tuple) and len(layer) == 2:\n layer, multiplier = layer\n init_multiplier = 1\n elif isinstance(layer, tuple) and len(layer) == 3:\n layer, init_multiplier, multiplier = layer\n else:\n multiplier = 1\n init_multiplier = 1\n lr = config.lr * multiplier\n init_lr = config.lr * multiplier * init_multiplier\n logger.info('Layer=%d, lr=%.5f', i, init_lr)\n parameters.append({'params': layer.parameters(), 'lr': init_lr, 'after_warmup_lr': lr})\n else:\n logger.info('Optimizing all parameters, lr=%.5f', config.lr)\n parameters = model.parameters()\n\n if opt_type == 'sgd':\n optimizer = torch.optim.SGD(parameters, config.lr, momentum=config.momentum, weight_decay=config.weight_decay)\n elif opt_type == 'adam':\n optimizer = torch.optim.Adam(parameters, lr=config.lr, weight_decay=config.weight_decay)\n elif opt_type == 'yf':\n optimizer = YFOptimizer(parameters, config.lr, mu=config.momentum, weight_decay=config.weight_decay,\n clip_thresh=0.1)\n else:\n raise TypeError, 'Unknown optimizer type=%s' % (opt_type, )\n return optimizer","def load_checkpoint(self, session, model_dir):\n assert self.params.cp_load == True, (\"cp_load must be set to true to load a checkpoint\")\n self.loader.restore(session, model_dir)","def load_checkpoint(filepath):\n checkpoint = torch.load(filepath)\n \n arch = checkpoint['arch']\n if arch == 'vgg':\n model = models.vgg16(pretrained=True)\n elif arch == 'densenet':\n model = models.densenet121(pretrained=True) \n \n model.class_to_idx = checkpoint['class_to_idx']\n model.classifier = checkpoint['classifier']\n model.classifier.load_sate_dict = checkpoint['classifier_state_dict']\n model.optimizer = checkpoint['optimizer_state_dict']\n model.input_size = checkpoint['input_size']\n model.output_size = checkpoint['output_size']\n \n return model","def state_create(recipe, stage, devtype):\n\n # subsequent `.load_state_dict()` automatically moves to device and casts\n # `model` stage in a stage are allowed to be None\n model = get_model(recipe, **stage[\"model\"]).to(**devtype)\n\n # base lr is specified in the optimizer settings\n optim = get_optimizer(model, stage[\"optimizer\"])\n\n # name-id mapping for copying optimizer states\n mapper = {k: id(p) for k, p in model.named_parameters()}\n\n return State(model, optim, mapper)"],"string":"[\n \"def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\\n self.model.load_state_dict(checkpoint[\\\"model_state_dict\\\"])\\n self.optimizer.load_state_dict(checkpoint[\\\"optimizer_state_dict\\\"])\\n return self\",\n \"def create_optimizer(self) -> None:\\n # Make sure model is created before we create optimizer\\n if self._model is None:\\n raise ValueError(\\\"Model checkpoint must be created before optimizer checkpoint can be loaded.\\\")\\n\\n # Select optimizer type\\n if self.config.optimizer_type in [OptimizerType.Adam, OptimizerType.AMSGrad]:\\n self._optimizer = torch.optim.Adam(self._model.parameters(), self.config.l_rate,\\n self.config.adam_betas, self.config.opt_eps, self.config.weight_decay,\\n amsgrad=self.config.optimizer_type == OptimizerType.AMSGrad)\\n elif self.config.optimizer_type == OptimizerType.SGD:\\n self._optimizer = torch.optim.SGD(self._model.parameters(), self.config.l_rate, self.config.momentum,\\n weight_decay=self.config.weight_decay)\\n elif self.config.optimizer_type == OptimizerType.RMSprop:\\n self._optimizer = RMSprop(self._model.parameters(), self.config.l_rate, self.config.rms_alpha,\\n self.config.opt_eps,\\n self.config.weight_decay, self.config.momentum)\\n else:\\n raise NotImplementedError(f\\\"Optimizer type {self.config.optimizer_type.value} is not implemented\\\")\",\n \"def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\\n print(\\\"Load checkpoint from: {}\\\".format(path))\\n state_dict, optimizer_state = _load(path)\\n\\n model.load_dict(state_dict)\\n if not reset_optimizer and optimizer is not None:\\n if optimizer_state is not None:\\n print(\\\"[loading] Load optimizer state from {}\\\".format(path))\\n optimizer.load(optimizer_state)\\n\\n return model\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(f\\\"Checkpoint '{checkpoint_path}' does not exist\\\")\\n\\n state = torch.load(checkpoint_path)\\n try:\\n model.load_state_dict(state['model_state_dict'])\\n except BaseException as e:\\n print('Failed to do something: ' + str(e))\\n\\n if optimizer is not None:\\n try:\\n optimizer.load_state_dict(state['optimizer_state_dict'])\\n except Exception as e:\\n print(e)\\n\\n return state\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n model_state_dict, optimizer_state_dict = torch.load(checkpoint)\\n model.load_state_dict(model_state_dict)\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(optimizer_state_dict)\",\n \"def opt_from_checkpoint(\\n checkpoint_path: str,\\n config_path: Optional[str] = None,\\n extra_bindings=tuple([])\\n) -> Optimizer:\\n\\n if config_path is None:\\n config_path = \\\"/\\\".join(checkpoint_path.split(\\\"/\\\")[:-1]) + \\\"/config.gin\\\"\\n\\n logging.info(\\\"Restoring configs from: %s\\\", config_path)\\n with gin.unlock_config():\\n scope = f\\\"opt_from_checkpoint__{str(uuid.uuid4()).replace('-', '_')}\\\"\\n with gin.config_scope(None):\\n with gin.config_scope(scope):\\n if config_path:\\n with file_open(config_path, \\\"rb\\\") as f:\\n content = bytes(f.read()).decode(\\\"utf-8\\\")\\n\\n # gin writes out multi line sometimes, undo this.\\n content = content.replace(\\\"\\\\\\\\\\\\n\\\", \\\"\\\")\\n\\n def maybe_add_scope(c):\\n # filter out train as this overlaps with outer_training.\\n if c.startswith(\\\"#\\\"):\\n return None\\n if \\\"=\\\" in c:\\n return scope + \\\"/\\\" + c\\n return c\\n\\n bindings = [maybe_add_scope(c) for c in content.split(\\\"\\\\n\\\")]\\n bindings = [b for b in bindings if b]\\n bindings = bindings + [maybe_add_scope(c) for c in extra_bindings]\\n\\n logging.info(\\\"Parsing bindings\\\")\\n for b in bindings:\\n logging.info(b)\\n print(b)\\n gin.parse_config(bindings, skip_unknown=True)\\n\\n configurable = gin.query_parameter(f\\\"{scope}/run_train.lopt\\\")\\n if isinstance(configurable, gin.config._UnknownConfigurableReference): # pylint: disable=protected-access\\n raise ValueError(\\\"Gin couldn't find the learned optimizer in current\\\"\\n \\\" imports. Did you forget to import the module?\\\")\\n\\n # with summary.summary_scope(\\\"opt_from_checkpoint\\\"):\\n lopt = configurable.configurable.wrapped()\\n theta = lopt.init(jax.random.PRNGKey(0))\\n logging.info(f\\\"Restoring checkpoint {checkpoint_path}\\\") # pylint: disable=logging-fstring-interpolation\\n ckpt = ParameterCheckpoint(theta, \\\"\\\", 0)\\n ckpt = load_state(checkpoint_path, ckpt)\\n opt = lopt.opt_fn(ckpt.params)\\n return opt\\n # wrapped = _GinScopeClass(opt, scope)\\n # For now, just add the lopt to the returned class.\\n # TODO(lmetz) change this api to return a more structured class?\\n # wrapped.lopt = lopt\\n # return wrapped # type: ignore\",\n \"def _load(checkpoint_path):\\n state_dict, optimizer_state = dg.load_persistables(dirname=checkpoint_path)\\n return state_dict, optimizer_state\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None,\\n model_key='model_state_dict', optimizer_key='optimizer_state_dict'):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(f\\\"Checkpoint '{checkpoint_path}' does not exist\\\")\\n\\n state = torch.load(checkpoint_path, map_location='cpu')\\n model.load_state_dict(state[model_key])\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(state[optimizer_key])\\n\\n return state\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint)\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(\\\"Checkpoint '{}' does not exist\\\".format(checkpoint_path))\\n\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else 'cpu')\\n state = torch.load(checkpoint_path, map_location=\\\"cuda:0\\\")\\n model.load_state_dict(state['model_state_dict'])\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(state['optimizer_state_dict'])\\n\\n return state\",\n \"def try_load_checkpoint_for_optimizer(self) -> bool:\\n\\n if self._optimizer is None:\\n raise ValueError(\\\"Optimizer must be created before optimizer checkpoint can be loaded.\\\")\\n\\n if not self.checkpoint_path:\\n logging.warning(\\\"No checkpoint path provided.\\\")\\n return False\\n\\n if not self.checkpoint_path.is_file():\\n logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')\\n return False\\n\\n logging.info(f\\\"Loading checkpoint {self.checkpoint_path}\\\")\\n checkpoint = ModelAndInfo.read_checkpoint(self.checkpoint_path, self.config.use_gpu)\\n\\n try:\\n state_dict = checkpoint[ModelAndInfo.OPTIMIZER_STATE_DICT_KEY]\\n except KeyError:\\n logging.error(f\\\"Key {ModelAndInfo.OPTIMIZER_STATE_DICT_KEY} not found in checkpoint\\\")\\n return False\\n\\n self._optimizer.load_state_dict(state_dict)\\n\\n logging.info(f\\\"Loaded optimizer from checkpoint (epoch: {checkpoint[ModelAndInfo.EPOCH_KEY]})\\\")\\n self.checkpoint_epoch = checkpoint[ModelAndInfo.EPOCH_KEY]\\n return True\",\n \"def load(self, path):\\n checkpoint = torch.load(path)\\n self.load_state_dict(checkpoint['model_state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\",\n \"def load(self, path):\\n checkpoint = torch.load(path)\\n self.load_state_dict(checkpoint['model_state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\",\n \"def LoadProgramState(self, restored_checkpoint_path=None, sess=None):\\n pass\",\n \"def create_optimizer(net, optimizer_state_dict, learning_rate, device='cuda'):\\n # define optimizer\\n optimizer = optim.Adam([{\\n 'params': net.net.parameters(),\\n 'initial_lr': learning_rate\\n }])\\n # load optimizer checkpoint if available\\n if optimizer_state_dict is not None:\\n target_device = 'cpu' if device == 'cpu' else 'cuda'\\n # load the optimizer weights\\n optimizer.load_state_dict(optimizer_state_dict)\\n for state in optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = getattr(v, target_device)()\\n return optimizer\",\n \"def load_model_from_checkpoint(self, path: str):\\n ckpt = torch.load(path, map_location='cpu')\\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\\n self.net_q.head.load_state_dict(ckpt['head'])\\n self.net_ps.load_state_dict(ckpt['net_ps'])\\n self.net_k.load_state_dict(ckpt['net_k'])\\n self.queue.load_state_dict(ckpt['queue'])\\n self.optimizer.load_state_dict(ckpt['optimizer'])\\n if 'scheduler' in ckpt:\\n self.scheduler.load_stae_dict(ckpt['scheduler'])\\n self.move_optimizer_states(self.optimizer, self.local_rank)\",\n \"def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\\n print(\\\"Loading checkpoint: {}\\\".format(checkpoint_path))\\n state = torch.load(checkpoint_path)\\n self.model.load_state_dict(state['state_dict'])\\n self.optimizer.load_state_dict(state['optim_dict'])\\n\\n if continue_from_epoch:\\n self.epoch = state['epoch']\",\n \"def create_optimizer(parameters, optimizer_class, optim_params, model_name='model'):\\n opt = optimizer_class(parameters, **optim_params)\\n if special_parameters.load_model:\\n _load_optimizer(opt, model_name)\\n return opt\",\n \"def load_state_dict(self, checkpoint):\\n self.net.load_state_dict(checkpoint['Net'])\\n self.optimizer.load_state_dict(checkpoint['Optimizer'])\\n\\n if ADVERSARIAL_FLAG:\\n self.adv_net.load_state_dict(checkpoint['AdvNet'])\\n self.adv_optimizer.load_state_dict(checkpoint['AdvOptimizer'])\\n\\n self.history = checkpoint['History']\\n self.stats = checkpoint['Stats']\\n\\n # The following loops are used to fix a bug that was\\n # discussed here: https://github.com/pytorch/pytorch/issues/2830\\n # (it is supposed to be fixed in recent PyTorch version)\\n for state in self.optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = v.to(self.net.device)\\n if ADVERSARIAL_FLAG:\\n for adv_state in self.adv_optimizer.state.values():\\n for k, v in adv_state.items():\\n if isinstance(v, torch.Tensor):\\n adv_state[k] = v.to(self.adv_net.device)\",\n \"def load_model(agent, optimizer, model_file):\\n checkpoint = torch.load(model_file)\\n episode = checkpoint['epoch']\\n agent.load_state_dict(checkpoint['model_state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\n return episode\",\n \"def load_checkpoint(self, filename, load_optim=True):\\n extra_state, optim_history, last_optim_state = \\\\\\n utils.load_model_state(filename, self.get_model())\\n\\n if last_optim_state is not None:\\n # rebuild optimizer after loading model, since params may have changed\\n #self.optimizer = optim.build_optimizer(self.args, self.model.parameters())\\n self.lr_scheduler = lr_scheduler.build_lr_scheduler(self.args, self.optimizer)\\n\\n if load_optim:\\n self._optim_history = optim_history\\n # only reload optimizer and lr_scheduler if they match\\n last_optim = self._optim_history[-1]\\n if last_optim['criterion_name'] == self.criterion.__class__.__name__:\\n self.lr_scheduler.load_state_dict(last_optim['lr_scheduler_state'])\\n if last_optim['optimizer_name'] == self.optimizer.__class__.__name__:\\n self.optimizer.load_state_dict(last_optim_state)\\n\\n self._num_updates = last_optim['num_updates']\\n\\n return extra_state\",\n \"def _create_optimizer(self):\\n\\n with tf.name_scope(\\\"optimizer\\\"):\\n self.train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.loss)\",\n \"def create_optimizer(self, context, optimizer, host):\\n pass\",\n \"def _load_state_dict(optimizer, state: dict) -> None:\\n if is_scheduler(optimizer):\\n optimizer.load_state_dict(state[\\\"scheduler\\\"])\\n optimizer.optimizer.load_state_dict(state[\\\"optimizer\\\"])\\n else:\\n optimizer.load_state_dict(state)\",\n \"def load_state(net, optimizer, scheduler, model_no=0, load_best=False):\\n logger.info(\\\"Initializing model and optimizer states...\\\")\\n base_path = \\\"./data/\\\"\\n checkpoint_path = os.path.join(base_path,\\\"test_checkpoint_%d.pth.tar\\\" % model_no)\\n best_path = os.path.join(base_path,\\\"test_model_best_%d.pth.tar\\\" % model_no)\\n start_epoch, best_pred, checkpoint = 0, 0, None\\n if (load_best == True) and os.path.isfile(best_path):\\n checkpoint = torch.load(best_path)\\n logger.info(\\\"Loaded best model.\\\")\\n elif os.path.isfile(checkpoint_path):\\n checkpoint = torch.load(checkpoint_path)\\n logger.info(\\\"Loaded checkpoint model.\\\")\\n if checkpoint != None:\\n start_epoch = checkpoint['epoch']\\n best_pred = checkpoint['best_acc']\\n net.load_state_dict(checkpoint['state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n scheduler.load_state_dict(checkpoint['scheduler'])\\n logger.info(\\\"Loaded model and optimizer.\\\") \\n return start_epoch, best_pred\",\n \"def load_from_checkpoint(self, path):\\n print(f'# loading trainer state from {path}')\\n checkpoint = torch.load(path)\\n self.load(checkpoint)\",\n \"def load_ckp(checkpoint_fpath, model, optimizer, device):\\n\\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\\n model.load_state_dict(checkpoint['state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n valid_acc = checkpoint['valid_acc'] \\n return model, optimizer, checkpoint['epoch'], valid_acc\",\n \"def load_checkpoint(self, model, optimizers):\\n self.epoch = get_last_epoch(self.log_path)\\n\\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\\n model.load_state_dict(model_state_dict)\\n\\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\\n for opt_ind in range(len(optimizers)):\\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\\n\\n schedulers = load_sched(optimizers, self.epoch)\\n\\n return model, optimizers, schedulers\",\n \"def load_model(path, model, optimizer):\\n print(\\\"LOADING MODEL...\\\")\\n ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)\\n status = ckpt.restore(tf.train.latest_checkpoint(path))\\n ckpt_manager = tf.train.CheckpointManager(\\n checkpoint=ckpt, \\n directory=FLAGS.model_dir, \\n max_to_keep=3 \\n )\\n return model, optimizer, ckpt, ckpt_manager\",\n \"def testSaveAndLoad(self):\\n layers = (2, 3)\\n net_options = {\\\"layers\\\": layers, \\\"initializer\\\": \\\"zeros\\\"}\\n num_unrolls = 2\\n num_epochs = 1\\n\\n problem = problems.simple()\\n\\n # Original optimizer.\\n with tf.Graph().as_default() as g1:\\n optimizer = meta.MetaOptimizer(net=dict(\\n net=\\\"CoordinateWiseDeepLSTM\\\",\\n net_options=net_options))\\n minimize_ops = optimizer.meta_minimize(problem, 3)\\n\\n with self.test_session(graph=g1) as sess:\\n sess.run(tf.global_variables_initializer())\\n train(sess, minimize_ops, 1, 2)\\n\\n # Save optimizer.\\n tmp_dir = tempfile.mkdtemp()\\n save_result = optimizer.save(sess, path=tmp_dir)\\n net_path = next(iter(save_result))\\n\\n # Retrain original optimizer.\\n cost, x = train(sess, minimize_ops, num_unrolls, num_epochs)\\n\\n # Load optimizer and retrain in a new session.\\n with tf.Graph().as_default() as g2:\\n optimizer = meta.MetaOptimizer(net=dict(\\n net=\\\"CoordinateWiseDeepLSTM\\\",\\n net_options=net_options,\\n net_path=net_path))\\n minimize_ops = optimizer.meta_minimize(problem, 3)\\n\\n with self.test_session(graph=g2) as sess:\\n sess.run(tf.global_variables_initializer())\\n cost_loaded, x_loaded = train(sess, minimize_ops, num_unrolls, num_epochs)\\n\\n # The last cost should be the same.\\n self.assertAlmostEqual(cost, cost_loaded, places=3)\\n self.assertAlmostEqual(x[0], x_loaded[0], places=3)\\n\\n # Cleanup.\\n os.remove(net_path)\\n os.rmdir(tmp_dir)\",\n \"def on_stage_start(self, state: _State):\\n optimizer = state.get_attr(\\n key=\\\"optimizer\\\", inner_key=self.optimizer_key\\n )\\n assert optimizer is not None\\n self._optimizer = optimizer\",\n \"def build_trainer(restore_state=None, train_policies=None, config=None):\\n \\n print(\\\"Using config\\\")\\n print(config)\\n cls = PPOTrainer\\n trainer = cls(config=config)\\n env = trainer.workers.local_worker().env\\n if restore_state is not None:\\n trainer.restore_from_object(restore_state)\\n return trainer\",\n \"def load_checkpoint(tag, params, model):\\r\\n file_name = os.path.join(\\\"saved_models\\\", params.path, tag + \\\".pt\\\")\\r\\n logger.info(\\\"Load checkpoint from %s\\\" % file_name)\\r\\n if os.path.exists(file_name):\\r\\n checkpoint = torch.load(file_name, map_location='cpu')\\r\\n params.training_id = checkpoint['training_id']\\r\\n logger.info(checkpoint['training_id'])\\r\\n model.global_step = checkpoint['global_step']\\r\\n model.load_state_dict(checkpoint['model'])\\r\\n for i, optimizer in enumerate(model.optimizers):\\r\\n optimizer.load_state_dict(checkpoint['optimizers'][i])\\r\\n else:\\r\\n raise Exception(\\\"Checkpoint not found.\\\")\",\n \"def load(self, path):\\n file = open(path, 'rb')\\n state = pickle.load(file)\\n\\n self.opt_state = optimizers.pack_optimizer_state(state)\",\n \"def _load_optimizer(self):\\n # loss function\\n with tf.variable_scope(\\\"forward\\\"):\\n self.loss_fwd = tf.nn.seq2seq.sequence_loss(self.dec_outputs_fwd,\\n self.labels, self.weights, self.vocab_size)\\n\\n # optimizer\\n # self.optimizer_fwd = tf.train.MomentumOptimizer(self.learning_rate,\\n # self.momentum)\\n self.optimizer_fwd = tf.train.GradientDescentOptimizer(self.learning_rate)\\n self.train_op_fwd = self.optimizer_fwd.minimize(self.loss_fwd)\\n\\n with tf.variable_scope(\\\"backward\\\"):\\n self.loss_bwd = tf.nn.seq2seq.sequence_loss(self.dec_outputs_bwd,\\n self.labels, self.weights, self.vocab_size)\\n\\n # optimizer\\n # self.optimizer_bwd = tf.train.MomentumOptimizer(self.learning_rate,\\n # self.momentum)\\n self.optimizer_bwd = tf.train.GradientDescentOptimizer(self.learning_rate)\\n self.train_op_bwd = self.optimizer_bwd.minimize(self.loss_bwd)\",\n \"def load_pretrained(model, fname, optimizer=None):\\n if os.path.isfile(fname):\\n print(\\\"=> loading checkpoint '{}'\\\".format(fname))\\n checkpoint = torch.load(fname)\\n model.load_state_dict(checkpoint['state_dict'])\\n if optimizer is not None:\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n return model, optimizer, checkpoint['epoch']\\n else:\\n return model\\n else:\\n raise Exception(\\\"=> no checkpoint found at '{}'\\\".format(fname))\",\n \"def load_checkpoint(args, trainer, epoch_itr):\\n os.makedirs(os.path.join(args.save_dir, 'checkpoints'), exist_ok=True)\\n checkpoint_path = os.path.join(args.save_dir, 'checkpoints', args.restore_file)\\n if os.path.isfile(checkpoint_path):\\n extra_state = trainer.load_checkpoint(checkpoint_path)\\n if extra_state is not None:\\n # replay train iterator to match checkpoint\\n epoch_itr.load_state_dict(extra_state['train_iterator'])\\n\\n print('| loaded checkpoint {} (epoch {} @ {} updates)'.format(\\n checkpoint_path, epoch_itr.epoch, trainer.get_num_updates()))\\n\\n trainer.lr_step(epoch_itr.epoch)\\n trainer.lr_step_update(trainer.get_num_updates())\\n if 'best' in extra_state:\\n save_checkpoint.best = extra_state['best']\",\n \"def _resume_checkpoint(self, resume_path, model, optimizer):\\n if not resume_path:\\n return model, optimizer\\n\\n self.logger.info(f'Loading checkpoint: {resume_path}')\\n checkpoint = torch.load(resume_path)\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n # load optimizer state from checkpoint only when optimizer type is not changed.\\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\\n self.logger.warning(\\\"Warning: Optimizer type given in config file is different from \\\"\\n \\\"that of checkpoint. Optimizer parameters not being resumed.\\\")\\n else:\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n self.logger.info(f'Checkpoint \\\"{resume_path}\\\" loaded')\\n return model, optimizer\",\n \"def _create_train_op(self):\\n if self.optim_type == 'adagrad':\\n self.optimizer = tf.train.AdagradOptimizer(self.learning_rate)\\n elif self.optim_type == 'adam':\\n self.optimizer = tf.train.AdamOptimizer(self.learning_rate)\\n elif self.optim_type == 'rprop':\\n self.optimizer = tf.train.RMSPropOptimizer(self.learning_rate)\\n elif self.optim_type == 'sgd':\\n self.optimizer = tf.train.GradientDescentOptimizer(self.learning_rate)\\n else:\\n raise NotImplementedError('Unsupported optimizer: {}'.format(self.optim_type))\\n self.train_op = self.optimizer.minimize(self.loss)\",\n \"def _create_train_op(self):\\n if self.optim_type == 'adagrad':\\n self.optimizer = tf.train.AdagradOptimizer(self.learning_rate)\\n elif self.optim_type == 'adam':\\n self.optimizer = tf.train.AdamOptimizer(self.learning_rate)\\n elif self.optim_type == 'rprop':\\n self.optimizer = tf.train.RMSPropOptimizer(self.learning_rate)\\n elif self.optim_type == 'sgd':\\n self.optimizer = tf.train.GradientDescentOptimizer(self.learning_rate)\\n else:\\n raise NotImplementedError('Unsupported optimizer: {}'.format(self.optim_type))\\n self.train_op = self.optimizer.minimize(self.loss)\",\n \"def init_optimizer(self, kvstore='local', optimizer='sgd',\\n optimizer_params=(('learning_rate', 0.01),), force_init=False):\\n assert self.binded and self.params_initialized\\n\\n if self.optimizer_initialized and not force_init:\\n self.logger.warning('optimizer already initialized, ignoring...')\\n return\\n\\n if self._params_dirty:\\n self._sync_params_from_devices()\\n\\n (kvstore, update_on_kvstore) = \\\\\\n mx.model._create_kvstore(kvstore, len(self._context), self._arg_params)\\n\\n batch_size = self._exec_group.batch_size\\n if kvstore and 'dist' in kvstore.type and '_sync' in kvstore.type:\\n batch_size *= kvstore.num_workers\\n rescale_grad = 1.0 / batch_size\\n\\n\\n idx2name = {}\\n if update_on_kvstore:\\n idx2name.update(enumerate(self._exec_group.param_names))\\n else:\\n for k in range(len(self._context)):\\n idx2name.update({i*len(self._context)+k: n\\n for i, n in enumerate(self._exec_group.param_names)})\\n name2idx = {}\\n for k, v in idx2name.items():\\n if v not in name2idx:\\n name2idx[v] = []\\n name2idx[v].append(k)\\n\\n if isinstance(optimizer, str):\\n optimizer_params = dict(optimizer_params)\\n if 'rescale_grad' not in optimizer_params:\\n optimizer_params['rescale_grad'] = rescale_grad\\n optimizer = mx.optimizer.create(optimizer,\\n sym=self.symbol, param_idx2name=idx2name,\\n **optimizer_params)\\n else:\\n assert isinstance(optimizer, mx.optimizer.Optimizer)\\n if optimizer.rescale_grad != rescale_grad:\\n #pylint: disable=no-member\\n warnings.warn(\\n \\\"Optimizer created manually outside Module but rescale_grad \\\" +\\n \\\"is not normalized to 1.0/batch_size/num_workers (%s vs. %s). \\\"%(\\n optimizer.rescale_grad, rescale_grad) +\\n \\\"Is this intended?\\\", stacklevel=2)\\n if len(optimizer.idx2name):\\n warnings.warn(\\\"The idx2name of the optimizer is overwrote by ModuleEXT\\\")\\n # overwrite optimizer.idx2name\\n optimizer.idx2name = idx2name.copy()\\n\\n self._param_idx2name = idx2name \\n self._param_name2idx = name2idx\\n self._optimizer = optimizer\\n self._kvstore = kvstore\\n self._update_on_kvstore = update_on_kvstore\\n self._updater = None\\n\\n if kvstore:\\n if self._compression_params:\\n kvstore.set_gradient_compression(self._compression_params)\\n # copy initialized local parameters to kvstore\\n _initialize_kvstore(kvstore=kvstore,\\n param_arrays=self._exec_group.param_arrays,\\n arg_params=self._arg_params,\\n param_names=self._param_names,\\n update_on_kvstore=update_on_kvstore)\\n if update_on_kvstore:\\n kvstore.set_optimizer(self._optimizer)\\n else:\\n self._updater = mx.optimizer.get_updater(optimizer)\\n\\n self.optimizer_initialized = True\\n\\n if self._preload_opt_states is not None:\\n self.load_optimizer_states(self._preload_opt_states)\\n self._preload_opt_states = None\",\n \"def load_checkpoint(self, checkpoint_path=None):\\n if checkpoint_path is None:\\n checkpoint_path = self.get_latest_path()\\n\\n if os.path.isfile(checkpoint_path):\\n key = 'cuda' if torch.cuda.is_available() else 'cpu'\\n checkpoint = torch.load(checkpoint_path, map_location=key)\\n self.network.load_state_dict(checkpoint['network'])\\n self.network_target.load_state_dict(checkpoint['network_target'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n print('checkpoint loaded at {}'.format(checkpoint_path))\\n else:\\n raise OSError(\\\"Checkpoint file not found.\\\")\",\n \"def create_orttrainer_and_save_checkpoint_bart(device, trainer_opts, checkpoint_dir, state_dict_key_name='state_dict', use_lamb=True, seed=1, learning_rate=0.1):\\n torch.manual_seed(seed)\\n set_seed(seed)\\n\\n ort_trainer_opts = orttrainer.ORTTrainerOptions(trainer_opts)\\n optim_config = optim.LambConfig(lr=learning_rate) if use_lamb else optim.AdamConfig(lr=learning_rate)\\n model, model_desc = _load_bart_model()\\n trainer = orttrainer.ORTTrainer(model, model_desc, optim_config, options=ort_trainer_opts)\\n\\n # load dummy optimizer state as we are not going to run real training\\n dummy_init_state = generate_dummy_optim_state(model, optim_config)\\n init_state = copy.deepcopy(dummy_init_state)\\n trainer.load_state_dict(dummy_init_state)\\n\\n # run an eval step to innitialize the graph\\n src_tokens, prev_output_tokens, target = generate_random_input_from_bart_model_desc(model_desc, seed = seed)\\n trainer.eval_step(src_tokens, prev_output_tokens, target)\\n\\n # save current model parameters as a checkpoint\\n if checkpoint_dir:\\n if _is_model_parallel_run(ort_trainer_opts):\\n _save(trainer, checkpoint_dir, state_dict_key_name, world_rank=ort_trainer_opts.distributed.world_rank)\\n # save the initial complete model and optimizer states\\n if ort_trainer_opts.distributed.world_rank == 0:\\n init_state['model'] = {'full_precision': dict()}\\n for initializer in model.graph.initializer:\\n init_state['model']['full_precision'][initializer.name] = numpy_helper.to_array(initializer)\\n with open(os.path.join(checkpoint_dir, 'expected_state_dict.pkl'), \\\"wb\\\") as f:\\n pickle.dump(init_state, f)\\n else:\\n _save(trainer, checkpoint_dir, state_dict_key_name)\",\n \"def load_checkpoint(self, checkpoint: str, **kwargs) -> None:\\n with open(checkpoint, \\\"rb\\\") as f:\\n state = SafePickle.load(f)\\n\\n state_id = ray.put(state)\\n ray.get([worker.set_state.remote(state_id, **kwargs) for worker in self.remote_workers])\",\n \"def load_model(self, checkpoint):\\n print(f'Load parameters from {checkpoint}')\\n epoch = re.match(r\\\"[0-9]*\\\", os.path.basename(checkpoint)).group(0)\\n self.epoch_i = int(epoch)\\n self.model.load_state_dict(torch.load(checkpoint))\",\n \"def unpack_checkpoint(\\n self,\\n checkpoint: Dict,\\n model=None,\\n criterion=None,\\n optimizer=None,\\n scheduler=None,\\n **kwargs,\\n ) -> None:\\n super().unpack_checkpoint(\\n checkpoint,\\n model=model,\\n criterion=criterion,\\n optimizer=optimizer,\\n scheduler=scheduler,\\n **kwargs,\\n )\\n\\n # NOTE: propper way to load state, docs:\\n # https://nvidia.github.io/apex/amp.html#checkpointing\\n if \\\"amp\\\" in checkpoint:\\n amp.load_state_dict(checkpoint[\\\"amp\\\"])\",\n \"def unpack_checkpoint(\\n self,\\n checkpoint: Dict,\\n model=None,\\n criterion=None,\\n optimizer=None,\\n scheduler=None,\\n **kwargs,\\n ) -> None:\\n super().unpack_checkpoint(\\n checkpoint,\\n model=model,\\n criterion=criterion,\\n optimizer=optimizer,\\n scheduler=scheduler,\\n **kwargs,\\n )\\n\\n # NOTE: propper way to load state, docs:\\n # https://nvidia.github.io/apex/amp.html#checkpointing\\n if \\\"amp\\\" in checkpoint:\\n amp.load_state_dict(checkpoint[\\\"amp\\\"])\",\n \"def load(loadname, checkpoint=None):\\n ckpt_dir = \\\"./models/tf_ckpt_\\\" + loadname + \\\"/\\\"\\n if checkpoint is not None:\\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\\n status.assert_consumed()\\n print(\\\"Loaded checkpoint\\\")\\n else:\\n print(\\\"Not Loading any checkpoint\\\")\\n print(\\\"Starting training from initial configuration\\\")\",\n \"def load_optimizers(self, epoch):\\n for i, optimizer in enumerate(self.optimizers):\\n load_filename = '{0}_optimizer_{1}.pth'.format(epoch, i)\\n load_path = os.path.join(self.save_dir, load_filename)\\n print('loading the optimizer from {0}'.format(load_path))\\n state_dict = torch.load(load_path)\\n if hasattr(state_dict, '_metadata'):\\n del state_dict._metadata\\n optimizer.load_state_dict(state_dict)\",\n \"def train(self, num_epochs, state_transition_model, save_weights_path='./stored_data/weights/policy_network/policy_network',\\n load_weights=False, load_weights_path=None):\\n with self.sess as sess: \\n stm_weights_path = ('./stored_data/weights/state_transition_model/state_transition_model_'\\n + self.energy_system.electricity_pricing_model + '.h5')\\n state_transition_model.load_weights(stm_weights_path)\\n\\n starting_state = tf.placeholder(tf.float32, shape=(None, self.num_state_variables), name='starting_state')\\n normalized_starting_state_vals = self._get_normalized_starting_state_values_and_set_battery_soc()\\n print(\\\"\\\\nNow creating computational graph\\\")\\n print(\\\"Available memory in GB:\\\", psutil.virtual_memory().available / 1000000000.0)\\n average_reward_per_rollout_op, average_electricity_cost_per_rollout_op = self.simulate_epoch(starting_state, state_transition_model)\\n print(\\\"\\\\nNow creating optimizer op\\\")\\n print(\\\"Available memory in GB:\\\", psutil.virtual_memory().available / 1000000000.0)\\n train_op = tf.train.AdamOptimizer().minimize(-average_reward_per_rollout_op, \\n var_list=[self.model.trainable_variables],\\n name='policy_optimizer')\\n print(\\\"\\\\nNow merging sumaries\\\")\\n print(\\\"Available memory in GB:\\\", psutil.virtual_memory().available / 1000000000.0)\\n merged_tensorboard_summary = tf.summary.merge_all()\\n writer = tf.summary.FileWriter('./stored_data/Tensorboard/policy_network/' + self.energy_system.electricity_pricing_model + '/')\\n #writer.add_graph(sess.graph)\\n\\n print(\\\"\\\\nNow initializing variables\\\")\\n print(\\\"Available memory in GB:\\\", psutil.virtual_memory().available / 1000000000.0)\\n self._initialize_local_and_global_variables()\\n self.training_average_electricity_cost_in_euros = np.zeros(num_epochs)\\n self.training_average_reward = np.zeros(num_epochs)\\n\\n if load_weights:\\n self.load_weights(load_weights_path)\\n\\n feed_dict = {starting_state: normalized_starting_state_vals}\\n print(\\\"\\\\nNow running first epoch\\\")\\n print(\\\"Available memory in GB:\\\", psutil.virtual_memory().available / 1000000000.0)\\n for epoch in range(num_epochs):\\n op_list = [train_op, average_reward_per_rollout_op, average_electricity_cost_per_rollout_op, merged_tensorboard_summary]\\n _, epoch_average_reward, epoch_average_electricity_cost, epoch_summary = sess.run(op_list, feed_dict=feed_dict)\\n self.training_average_electricity_cost_in_euros[epoch] = epoch_average_electricity_cost\\n self.training_average_reward[epoch] = epoch_average_reward\\n if epoch % 10 == 0 or epoch == num_epochs-1:\\n writer.add_summary(epoch_summary, epoch)\\n print(\\\"Finished \\\" + str(epoch+1) + \\\" epochs out of \\\" + str(num_epochs)\\n + \\\". Electricity cost: %.3f euros\\\" % epoch_average_electricity_cost)\\n if epoch >= 99 and (epoch + 1) % 50 == 0:\\n self.model.save_weights(save_weights_path + '_'\\n + self.energy_system.electricity_pricing_model + '_'\\n + str(epoch + 1)\\n + '.h5')\\n\\n if num_epochs > 0:\\n self.save_weights_and_monitoring_data(save_weights_path)\\n\\n self.plot_progress()\",\n \"def load_checkpoint(path):\\n\\n # Get the model name\\n model_name = path.split('-')[0]\\n assert (model_name in ['vgg16', 'resnet50'\\n ]), \\\"Path must have the correct model name\\\"\\n\\n # Load in checkpoint\\n checkpoint = torch.load(path)\\n\\n if model_name == 'vgg16':\\n model = models.vgg16(pretrained=True)\\n # Make sure to set parameters as not trainable\\n for param in model.parameters():\\n param.requires_grad = False\\n model.classifier = checkpoint['classifier']\\n\\n elif model_name == 'resnet50':\\n model = models.resnet50(pretrained=True)\\n # Make sure to set parameters as not trainable\\n for param in model.parameters():\\n param.requires_grad = False\\n model.fc = checkpoint['fc']\\n\\n # Load in the state dict\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n total_params = sum(p.numel() for p in model.parameters())\\n print(f'{total_params:,} total parameters.')\\n total_trainable_params = sum(\\n p.numel() for p in model.parameters() if p.requires_grad)\\n print(f'{total_trainable_params:,} total gradient parameters.')\\n\\n # Move to gpu\\n if multi_gpu:\\n model = nn.DataParallel(model)\\n\\n if train_on_gpu:\\n model = model.to('cuda')\\n\\n # Model basics\\n model.class_to_idx = checkpoint['class_to_idx']\\n model.idx_to_class = checkpoint['idx_to_class']\\n model.epochs = checkpoint['epochs']\\n\\n # Optimizer\\n optimizer = checkpoint['optimizer']\\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\n\\n return model, optimizer\",\n \"def train(config, alg, checkpoint=None):\\n agent = get_agent_class(alg)(config=config, env=\\\"retro-v0\\\")\\n if checkpoint is not None:\\n try:\\n agent.restore(checkpoint)\\n print(f\\\"Resumed checkpoint {checkpoint}\\\")\\n except:\\n print(\\\"Checkpoint not found: restarted policy network from scratch\\\")\\n else:\\n print(\\\"Started policy network from scratch\\\")\\n\\n for i in range(1000000):\\n # Perform one iteration of training the policy with the algorithm\\n result = agent.train()\\n print(pretty_print(result))\\n\\n if i % 50 == 0:\\n checkpoint = agent.save()\\n print(\\\"checkpoint saved at\\\", checkpoint)\",\n \"def load_checkpoint_train(cpdir, model, optimizer):\\n start_epoch = 0\\n start_global_step = 0\\n if cpdir is not None:\\n start_global_step, start_epoch = load_checkpoint(\\n cpdir, model, optimizer)\\n start_global_step += 1\\n start_epoch += 1\\n return start_global_step, start_epoch\",\n \"def reload_checkpoint(self):\\n checkpoint_path = os.path.join(self.params.dump_path, 'checkpoint.pth')\\n if not os.path.isfile(checkpoint_path):\\n if self.params.reload_checkpoint == '':\\n return\\n else:\\n checkpoint_path = self.params.reload_checkpoint\\n assert os.path.isfile(checkpoint_path)\\n logger.warning(\\\"Reloading checkpoint from %s ...\\\" % checkpoint_path)\\n data = torch.load(checkpoint_path, map_location='cpu')\\n\\n # reload model parameters\\n for name in self.MODEL_NAMES:\\n getattr(self, name).load_state_dict(data[name])\\n\\n # reload optimizers\\n for name in self.optimizers.keys():\\n if False: # AMP checkpoint reloading is buggy, we cannot do that - TODO: fix - https://github.com/NVIDIA/apex/issues/250\\n logger.warning(\\\"Reloading checkpoint optimizer %s ...\\\" % name)\\n else: # instead, we only reload current iterations / learning rates\\n logger.warning(\\\"Not reloading checkpoint optimizer %s.\\\" % name)\\n for group_id, param_group in enumerate(self.optimizers[name].param_groups):\\n if 'num_updates' not in param_group:\\n logger.warning(\\\"No 'num_updates' for optimizer %s.\\\" % name)\\n continue\\n logger.warning(\\\"Reloading 'num_updates' and 'lr' for optimizer %s.\\\" % name)\\n param_group['num_updates'] = data['%s_optimizer' % name]['param_groups'][group_id]['num_updates']\\n param_group['lr'] = self.optimizers[name].get_lr_for_step(param_group['num_updates'])\\n\\n # reload main metrics\\n self.epoch = data['epoch'] + 1\\n self.n_total_iter = data['n_total_iter']\\n self.best_metrics = data['best_metrics']\\n self.best_stopping_criterion = data['best_stopping_criterion']\\n logger.warning(\\\"Checkpoint reloaded. Resuming at epoch %i / iteration %i ...\\\" % (self.epoch, self.n_total_iter))\",\n \"def _restore_checkpoint(self, checkpoint_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(checkpoint_path))\\n checkpoint = torch.load(checkpoint_path)\\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\\n \\n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\\n print('Parameters are inconsistant, adapting model parameters ...')\\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\\n del pretrained_dict['1']\\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\\n self.model.load_state_dict(model_dict)\\n else:\\n print('Parameters are consistant, load state dict directly ...')\\n self.model.load_state_dict(checkpoint['state_dict'])\\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\\n # if self.with_cuda:\\n # for state in self.optimizer.state.values():\\n # for k, v in state.items():\\n # if isinstance(v, torch.Tensor):\\n # state[k] = v.cuda(self.device)\",\n \"def create_or_load_model(model, model_dir, session, name):\\n latest_ckpt = tf.train.latest_checkpoint(model_dir)\\n if latest_ckpt:\\n start_time = time.time()\\n # It only takes a few seconds to initialize all variables.\\n session.run(tf.global_variables_initializer())\\n logging.info(\\n \\\"Initialize %s model with fresh parameters before loading variables \\\"\\n \\\"from the checkpoint, time %.2fs\\\", name,\\n time.time() - start_time)\\n model = load_model(model, latest_ckpt, session, name)\\n else:\\n start_time = time.time()\\n session.run(tf.global_variables_initializer())\\n session.run(tf.tables_initializer())\\n utils.print_out(\\\" created %s model with fresh parameters, time %.2fs\\\" %\\n (name, time.time() - start_time))\\n\\n global_step = model.global_step.eval(session=session)\\n return model, global_step\",\n \"def load_states(self, checkpoint):\\n raise NotImplementedError()\",\n \"def from_checkpoint(\\n checkpoint: Union[str, Checkpoint],\\n policy_ids: Optional[Container[PolicyID]] = None,\\n policy_mapping_fn: Optional[Callable[[AgentID, EpisodeID], PolicyID]] = None,\\n policies_to_train: Optional[\\n Union[\\n Container[PolicyID],\\n Callable[[PolicyID, Optional[SampleBatchType]], bool],\\n ]\\n ] = None,\\n ) -> \\\"Algorithm\\\":\\n checkpoint_info = get_checkpoint_info(checkpoint)\\n\\n # Not possible for (v0.1) (algo class and config information missing\\n # or very hard to retrieve).\\n if checkpoint_info[\\\"checkpoint_version\\\"] == version.Version(\\\"0.1\\\"):\\n raise ValueError(\\n \\\"Cannot restore a v0 checkpoint using `Algorithm.from_checkpoint()`!\\\"\\n \\\"In this case, do the following:\\\\n\\\"\\n \\\"1) Create a new Algorithm object using your original config.\\\\n\\\"\\n \\\"2) Call the `restore()` method of this algo object passing it\\\"\\n \\\" your checkpoint dir or AIR Checkpoint object.\\\"\\n )\\n elif checkpoint_info[\\\"checkpoint_version\\\"] < version.Version(\\\"1.0\\\"):\\n raise ValueError(\\n \\\"`checkpoint_info['checkpoint_version']` in `Algorithm.from_checkpoint\\\"\\n \\\"()` must be 1.0 or later! You are using a checkpoint with \\\"\\n f\\\"version v{checkpoint_info['checkpoint_version']}.\\\"\\n )\\n\\n # This is a msgpack checkpoint.\\n if checkpoint_info[\\\"format\\\"] == \\\"msgpack\\\":\\n # User did not provide unserializable function with this call\\n # (`policy_mapping_fn`). Note that if `policies_to_train` is None, it\\n # defaults to training all policies (so it's ok to not provide this here).\\n if policy_mapping_fn is None:\\n # Only DEFAULT_POLICY_ID present in this algorithm, provide default\\n # implementations of these two functions.\\n if checkpoint_info[\\\"policy_ids\\\"] == {DEFAULT_POLICY_ID}:\\n policy_mapping_fn = AlgorithmConfig.DEFAULT_POLICY_MAPPING_FN\\n # Provide meaningful error message.\\n else:\\n raise ValueError(\\n \\\"You are trying to restore a multi-agent algorithm from a \\\"\\n \\\"`msgpack` formatted checkpoint, which do NOT store the \\\"\\n \\\"`policy_mapping_fn` or `policies_to_train` \\\"\\n \\\"functions! Make sure that when using the \\\"\\n \\\"`Algorithm.from_checkpoint()` utility, you also pass the \\\"\\n \\\"args: `policy_mapping_fn` and `policies_to_train` with your \\\"\\n \\\"call. You might leave `policies_to_train=None` in case \\\"\\n \\\"you would like to train all policies anyways.\\\"\\n )\\n\\n state = Algorithm._checkpoint_info_to_algorithm_state(\\n checkpoint_info=checkpoint_info,\\n policy_ids=policy_ids,\\n policy_mapping_fn=policy_mapping_fn,\\n policies_to_train=policies_to_train,\\n )\\n\\n return Algorithm.from_state(state)\",\n \"def create_train_state(\\n config, rng, learning_rate_fn, example_batch\\n):\\n model, variables, metric_collector = create_model(config, rng, example_batch)\\n params = variables['params']\\n parameter_overview.log_parameter_overview(params)\\n tx = train_utils.create_optimizer(config, learning_rate_fn)\\n\\n state = train_state.TrainState.create(\\n apply_fn=model.apply,\\n params=variables['params'],\\n tx=tx,\\n )\\n return model, state, metric_collector\",\n \"def load_checkpoint(ckpt_path):\\n checkpoint = None\\n if ckpt_path:\\n logger.info(\\\"Loading checkpoint from %s\\\" % ckpt_path)\\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\\\"cpu\\\"))\\n\\n if \\\"model\\\" in checkpoint.keys():\\n # This preserves backward-compat for models using customed layernorm\\n def fix_key(s):\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.b_2\\\", r\\\"\\\\1.layer_norm\\\\2.bias\\\", s\\n )\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.a_2\\\", r\\\"\\\\1.layer_norm\\\\2.weight\\\", s\\n )\\n return s\\n\\n checkpoint[\\\"model\\\"] = {\\n fix_key(k): v for k, v in checkpoint[\\\"model\\\"].items()\\n }\\n # Force add_ffnbias to True if bias found in model w_1 keys\\n for key in checkpoint[\\\"model\\\"].keys():\\n if \\\"w_1.bias\\\" in key:\\n checkpoint[\\\"opt\\\"].add_ffnbias = True\\n\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"num_kv\\\"):\\n checkpoint[\\\"opt\\\"].num_kv = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"add_ffnbias\\\"):\\n checkpoint[\\\"opt\\\"].add_ffnbias = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_residual\\\"):\\n checkpoint[\\\"opt\\\"].parallel_residual = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"shared_layer_norm\\\"):\\n checkpoint[\\\"opt\\\"].shared_layer_norm = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"use_ckpting\\\"):\\n checkpoint[\\\"opt\\\"].use_ckpting = []\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"relative_positions_buckets\\\"):\\n checkpoint[\\\"opt\\\"].relative_positions_buckets = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_mode\\\"):\\n checkpoint[\\\"opt\\\"].parallel_mode = \\\"data_parallel\\\"\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"norm_eps\\\"):\\n checkpoint[\\\"opt\\\"].norm_eps = 1e-6\\n\\n # fix v2 compatibility\\n if \\\"generator\\\" in checkpoint.keys() and checkpoint[\\\"generator\\\"]:\\n if \\\"0.weight\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"weight\\\"] = checkpoint[\\\"generator\\\"].pop(\\n \\\"0.weight\\\"\\n )\\n if \\\"0.bias\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"bias\\\"] = checkpoint[\\\"generator\\\"].pop(\\\"0.bias\\\")\\n # end of patch for backward compatibility\\n\\n return checkpoint\",\n \"def load(self):\\r\\n checkpoint = torch.load(self.checkpoint_path,\\r\\n map_location=self.device)\\r\\n self.load_state_dict(checkpoint)\\r\\n del checkpoint\",\n \"def initialize_optimization(self):\\n\\n if self.FLAGS.optimizer == \\\"Adam\\\" :\\n self.solver = tf.train.AdamOptimizer(\\n learning_rate = self.learning_rate,\\n beta1 = self.FLAGS.beta1,\\n beta2 = self.FLAGS.beta2)\\n else:\\n print(\\\"ERROR: Cannot handle optimizer type {}!!!\\\".format(self.FLAGS.optimizer))\\n raise RuntimeError\\n \\n # batch normalization in tensorflow requires this extra dependency\\n # this is required to update the moving mean and moving variance variables\\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n with tf.control_dependencies(extra_update_ops):\\n self.update = self.solver.minimize(self.loss, global_step=self.global_step)\",\n \"def importOptimizer():\\n module_path = os.path.join(path, \\\"optimization\\\")\\n module_path = os.path.join(module_path, \\\"optimizer.py\\\")\\n optimizer_class = importClass(\\\"Optimizer\\\", \\\"optimizer\\\", module_path)\\n return optimizer_class\",\n \"def create_orttrainer_and_load_checkpoint(device, trainer_opts, checkpoint_dir, use_lamb=True, seed=1, learning_rate=0.1):\\n torch.manual_seed(seed)\\n set_seed(seed)\\n\\n # PyTorch transformer model setup \\n optim_config = optim.LambConfig(lr=learning_rate) if use_lamb else optim.AdamConfig(lr=learning_rate)\\n model, model_desc, loss_fn, batcher_fn, train_data, _, _ = _load_pytorch_transformer_model(device)\\n trainer = orttrainer.ORTTrainer(model, model_desc, optim_config, loss_fn=loss_fn, options=orttrainer.ORTTrainerOptions(trainer_opts))\\n\\n # load checkpoint into trainer\\n checkpoint_file_name = 'checkpoint*.ortcp'\\n checkpoint_files = glob.glob(os.path.join(checkpoint_dir, checkpoint_file_name))\\n trainer.load_checkpoint(*checkpoint_files)\\n\\n # run an eval step to innitialize the graph\\n torch.manual_seed(seed)\\n set_seed(seed)\\n data, targets = batcher_fn(train_data, 0)\\n trainer.eval_step(data, targets)\\n\\n return trainer.state_dict(), model\",\n \"def _get_init_fn():\\n exclusions = []\\n if FLAGS.checkpoint_exclude_scopes:\\n exclusions = [scope.strip()\\n for scope in FLAGS.checkpoint_exclude_scopes.split(',')]\\n\\n variables_to_restore = []\\n for var in slim.get_model_variables():\\n excluded = False\\n for exclusion in exclusions:\\n if var.op.name.startswith(exclusion):\\n excluded = True\\n break\\n if not excluded:\\n variables_to_restore.append(var)\\n\\n if tf.gfile.IsDirectory(FLAGS.checkpoint_path):\\n checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)\\n else:\\n checkpoint_path = FLAGS.checkpoint_path\\n\\n tf.logging.info('Fine-tuning from {}'.format(checkpoint_path))\\n\\n return slim.assign_from_checkpoint_fn(checkpoint_path, variables_to_restore)\",\n \"def optimizer_factory(config, model):\\n params = model.parameters()\\n\\n optimizer = config[\\\"loss\\\"].get(\\\"optimizer\\\", \\\"Adam\\\")\\n lr = config[\\\"loss\\\"].get(\\\"lr\\\", 1e-3)\\n momentum = config[\\\"loss\\\"].get(\\\"momentum\\\", 0.9)\\n\\n if optimizer == \\\"SGD\\\":\\n return optim.SGD(params, lr=lr, momentum=momentum)\\n elif optimizer == \\\"Adam\\\":\\n return optim.Adam(params, lr=lr)\\n else:\\n raise NotImplementedError()\",\n \"def load(self):\\n checkpoint = torch.load(self.checkpoint_path,\\n map_location=self.net.device)\\n self.load_state_dict(checkpoint)\\n del checkpoint\",\n \"def load(self, checkpoint_dir=None):\\n\\n if checkpoint_dir is None:\\n checkpoint_dir = FLAGS.checkpoint_dir\\n\\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\\n\\n return self.load_from_path(checkpoint_dir)\",\n \"def _inst_optimizer(self):\\n optimizer = Optimizers(self.m_cfg['configs']['lr_politics']['optimizer']).value\\n lr_schedule = self.m_cfg['configs']['lr_politics']['lr']\\n opt = optimizer(learning_rate=lr_schedule)\\n return opt\",\n \"def build_optimizer(optimizer_config, params, name=None):\\n\\n if optimizer_config.name == 'rms_prop_optimizer':\\n\\n optimizer = paddle.optimizer.RMSProp(\\n parameters = params,\\n learning_rate=_get_base_lr_by_lr_scheduler(optimizer_config.learning_rate),\\n rho=optimizer_config.decay,\\n momentum=optimizer_config.momentum_optimizer_value,\\n epsilon=optimizer_config.epsilon,\\n weight_decay=optimizer_config.weight_decay)\\n\\n if optimizer_config.name =='momentum_optimizer':\\n\\n optimizer = paddle.optimizer.SGD(\\n parameters = params,\\n learning_rate=_get_base_lr_by_lr_scheduler(optimizer_config.learning_rate),\\n weight_decay=optimizer_config.weight_decay)\\n\\n if optimizer_config.name =='adam_optimizer':\\n\\n optimizer = paddle.optimizer.Adam(\\n parameters = params,\\n learning_rate=_get_base_lr_by_lr_scheduler(optimizer_config.learning_rate),\\n weight_decay=optimizer_config.weight_decay)\\n\\n if optimizer is None:\\n raise ValueError('Optimizer %s not supported.' % optimizer_config.name)\\n\\n if optimizer_config.use_moving_average:\\n raise ValueError('paddle don\\\\'t support moving average')\\n if name is None:\\n # assign a name to optimizer for checkpoint system\\n optimizer.name = optimizer_config.name\\n else:\\n optimizer.name = name\\n return optimizer\",\n \"def load_G(self, G_checkpoint):\\n checkpoint = torch.load(G_checkpoint)\\n self.G.load_state_dict(checkpoint['gnet'])\\n self.gen_optim.load_state_dict(checkpoint['gopt'])\",\n \"def load_sharded_optimizer(self, optimizer: Optimizer, index_file_path: str, size_per_shard: int):\\n raise NotImplementedError(\\\"Sharded optimizer checkpoint is not supported yet.\\\")\",\n \"def create_optimizer(optimizer_name, model, config):\\n if optimizer_name == 'adadelta':\\n return torch.optim.Adadelta(model.parameters(),\\n lr=config['adadelta_lr'],\\n rho=config['adadelta_rho'],\\n weight_decay=config['adadelta_weight_decay'],\\n eps=config['adadelta_eps'])\\n else:\\n raise Exception('Optimizer \\\\'{}\\\\' not supported.'.format(optimizer_name))\",\n \"def create_orttrainer_and_load_checkpoint_bart(device, trainer_opts, checkpoint_dir, use_lamb=True, seed=1, learning_rate=0.1):\\n torch.manual_seed(seed)\\n set_seed(seed)\\n\\n # model setup\\n optim_config = optim.LambConfig(lr=learning_rate) if use_lamb else optim.AdamConfig(lr=learning_rate)\\n model, model_desc = _load_bart_model()\\n trainer = orttrainer.ORTTrainer(model, model_desc, optim_config, options=orttrainer.ORTTrainerOptions(trainer_opts))\\n\\n # load checkpoint into trainer\\n checkpoint_file_name = 'checkpoint*.ortcp'\\n checkpoint_files = glob.glob(os.path.join(checkpoint_dir, checkpoint_file_name))\\n trainer.load_checkpoint(*checkpoint_files)\\n\\n # run an eval step to innitialize the graph\\n src_tokens, prev_output_tokens, target = generate_random_input_from_bart_model_desc(model_desc, seed = seed)\\n trainer.eval_step(src_tokens, prev_output_tokens, target)\\n\\n expected_state_dict = None\\n fname = os.path.join(checkpoint_dir, 'expected_state_dict.pkl')\\n if os.path.isfile(fname):\\n with open(fname, \\\"rb\\\") as f:\\n expected_state_dict = pickle.load(f)\\n\\n return trainer.state_dict(), expected_state_dict, model\",\n \"def optimizer_setup(model, params):\\n if params.optimizer == 'adam':\\n if params.freeze_backbone:\\n optimizer = optimizer_handler.layer_specific_adam(model, params)\\n else:\\n optimizer = optimizer_handler.plain_adam(model, params)\\n elif params.optimizer == 'sgd':\\n if params.freeze_backbone:\\n optimizer = optimizer_handler.layer_specific_sgd(model, params)\\n else:\\n optimizer = optimizer_handler.plain_sgd(model, params)\\n\\n if params.zero_bn_bias_decay:\\n optimizer = zero_wdcay_bn_bias(optimizer)\\n\\n return optimizer\",\n \"def init_optimizer(self, state_dict=None, use_gpu=True):\\n if self.args.fix_embeddings:\\n self.network.embedder.src_word_embeddings.fix_word_lut()\\n self.network.embedder.tgt_word_embeddings.fix_word_lut()\\n\\n if self.args.optimizer == 'sgd':\\n parameters = [p for p in self.network.parameters() if p.requires_grad]\\n self.optimizer = optim.SGD(parameters,\\n self.args.learning_rate,\\n momentum=self.args.momentum,\\n weight_decay=self.args.weight_decay)\\n\\n elif self.args.optimizer == 'adam':\\n parameters = [p for p in self.network.parameters() if p.requires_grad]\\n self.optimizer = optim.Adam(parameters,\\n self.args.learning_rate,\\n weight_decay=self.args.weight_decay)\\n elif self.args.optimizer == 'adamW':\\n parameters = [p for p in self.network.parameters() if p.requires_grad]\\n self.optimizer = optim.AdamW(parameters,\\n self.args.learning_rate,\\n weight_decay=self.args.weight_decay)\\n\\n else:\\n raise RuntimeError('Unsupported optimizer: %s' % self.args.optimizer)\\n\\n if state_dict is not None:\\n self.optimizer.load_state_dict(state_dict)\\n # FIXME: temp soln - https://github.com/pytorch/pytorch/issues/2830\\n if use_gpu:\\n for state in self.optimizer.state.values():\\n for k, v in state.items():\\n if torch.is_tensor(v):\\n state[k] = v.cuda()\",\n \"def load_model(self, ckpt_fn):\\n checkpoint = torch.load(ckpt_fn)\\n self.net_.load_state_dict(checkpoint[\\\"model\\\"])\\n self.optimizer_.load_state_dict(checkpoint[\\\"optimizer\\\"])\\n self.epoch_ = checkpoint[\\\"epoch\\\"]\\n self.global_step_ = checkpoint[\\\"global_step\\\"]\\n self.model_samples_ = deque(checkpoint[\\\"model_samples\\\"])\\n self.sampler.load_state_dict(checkpoint[\\\"sampler_state\\\"])\\n self.ais_loss.load_state_dict(checkpoint[\\\"ais_state\\\"])\\n self.replay_prob = checkpoint[\\\"replay_prob\\\"]\\n self.max_replay = checkpoint[\\\"max_replay\\\"]\",\n \"def load_D( self, D_checkpoint):\\n checkpoint = torch.load(D_checkpoint)\\n self.D.load_state_dict(checkpoint['dnet'])\\n self.dis_optim.load_state_dict(checkpoint['gopt'])\",\n \"def _create_train_op(self):\\n self.lr = self.learning_rate\\n # global_step = tf.train.get_or_create_global_step()\\n learning_rate = tf.constant(value=self.learning_rate, shape=[], dtype=tf.float32)\\n learning_rate =tf.train.exponential_decay(learning_rate,self.global_step,2*self.num_warm_up,0.96,staircase=True,name=\\\"exponential_decay\\\")\\n\\n # Implements linear warmup. I.e., if global_step < num_warmup_steps, the\\n # learning rate will be `global_step/num_warmup_steps * init_lr`.\\n if self.num_warm_up:\\n global_steps_int = tf.cast(self.global_step, tf.int32)\\n warmup_steps_int = tf.constant(self.num_warm_up, dtype=tf.int32)\\n\\n global_steps_float = tf.cast(global_steps_int, tf.float32)\\n warmup_steps_float = tf.cast(warmup_steps_int, tf.float32)\\n\\n warmup_percent_done = global_steps_float / warmup_steps_float\\n warmup_learning_rate = self.learning_rate * warmup_percent_done\\n\\n is_warmup = tf.cast(global_steps_int < warmup_steps_int, tf.float32)\\n learning_rate = (\\n (1.0 - is_warmup) * learning_rate + is_warmup * warmup_learning_rate)\\n self.current_learning_rate = learning_rate\\n if self.optim_type == 'adagrad':\\n self.optimizer = tf.train.AdagradOptimizer(self.lr)\\n elif self.optim_type == 'adam':\\n self.optimizer = tf.train.AdamOptimizer(learning_rate=self.lr)\\n elif self.optim_type == 'rprop':\\n self.optimizer = tf.train.RMSPropOptimizer(self.lr)\\n elif self.optim_type == 'sgd':\\n self.optimizer = tf.train.GradientDescentOptimizer(self.lr)\\n elif self.optim_type == \\\"bert\\\":\\n self.optimizer = AdamWeightDecayOptimizer(learning_rate=learning_rate, weight_decay_rate=0.01, beta_1=0.9,\\n beta_2=0.999, epsilon=1e-6,\\n exclude_from_weight_decay=[\\\"LayerNorm\\\", \\\"layer_norm\\\", \\\"bias\\\"])\\n else:\\n raise NotImplementedError('Unsupported optimizer: {}'.format(self.optim_type))\\n\\n self.logger.info(\\\"applying optimize %s\\\" % self.optim_type)\\n if self.clip_weight:\\n # clip_weight\\n tvars = tf.trainable_variables()\\n grads = tf.gradients(self.loss, tvars)\\n grads, _ = tf.clip_by_global_norm(grads, clip_norm=self.max_norm_grad)\\n grad_var_pairs = zip(grads, tvars)\\n train_op = self.optimizer.apply_gradients(grad_var_pairs, name='apply_grad', global_step=self.global_step)\\n new_global_step = self.global_step + 1\\n train_op = tf.group(train_op, [self.global_step.assign(new_global_step)])\\n self.train_op = train_op\\n else:\\n self.train_op = self.optimizer.minimize(self.loss, global_step=self.global_step)\",\n \"def from_checkpoints(\\n self,\\n restore_cfgs: Sequence[RestoreCheckpointConfig],\\n ds_iter: Optional[tf.data.Iterator] = None,\\n init_rng: Optional[jnp.ndarray] = None,\\n ) -> Iterator[train_state_lib.TrainState]:\\n\\n def _restore_path(path, cfg):\\n restore_checkpointer = cfg.checkpointer_cls(\\n train_state=self.global_train_state_shape,\\n partitioner=self._partitioner,\\n checkpoints_dir='', # unused for restore\\n dataset_iterator=ds_iter if cfg.restore_dataset else None,\\n restore_dtype=jnp.dtype(cfg.dtype) if cfg.dtype else None)\\n\\n from_tensorflow = gfile.exists(path + '.index')\\n if from_tensorflow and cfg.state_transformation_fns:\\n raise ValueError('Cannot initialize from a TensorFlow checkpoint using '\\n '`state_transformation_fns`.')\\n if from_tensorflow:\\n logging.info('Initializing parameters from TensorFlow checkpoint %s',\\n path)\\n return restore_checkpointer.restore_from_tf_checkpoint(\\n path, strict=cfg.strict)\\n\\n else:\\n if cfg.fallback_to_scratch:\\n if not cfg.state_transformation_fns:\\n raise ValueError('`state_transformation_fns` must be provided with '\\n '`fallback_to_scratch`')\\n if init_rng is None:\\n raise ValueError('An `init_rng` must be provided with '\\n '`fallback_to_scratch`')\\n fallback_state = self.from_scratch(init_rng).state_dict()\\n else:\\n fallback_state = None\\n\\n logging.info('Initializing parameters from specific T5X checkpoint %s',\\n path)\\n return restore_checkpointer.restore(\\n path=path,\\n state_transformation_fns=cfg.state_transformation_fns,\\n fallback_state=fallback_state)\\n\\n for restore_cfg in restore_cfgs:\\n paths = ([restore_cfg.path]\\n if isinstance(restore_cfg.path, str) else restore_cfg.path)\\n if restore_cfg.mode == 'specific':\\n logging.info('Restoring specific checkpoint(s): %s', paths)\\n for path in paths:\\n yield _restore_path(path, restore_cfg)\\n return\\n elif restore_cfg.mode in ('all', 'latest'):\\n for ckpt_dir in paths:\\n if not gfile.isdir(ckpt_dir):\\n raise ValueError(\\n 'Checkpoint path(s) must be valid directories when using '\\n \\\"restore mode 'all' or 'latest'.\\\")\\n # Check if this is a TensorFlow checkpoint dir.\\n tf_ckpt_state = tf.train.get_checkpoint_state(ckpt_dir)\\n\\n if tf_ckpt_state:\\n ckpt_paths = tf_ckpt_state.all_model_checkpoint_paths\\n else:\\n ckpt_paths = [\\n os.path.join(ckpt_dir, f'checkpoint_{step}')\\n for step in checkpoints.all_steps(ckpt_dir)\\n ]\\n if not ckpt_paths:\\n logging.info('No checkpoints found in specified directory: %s',\\n ckpt_dir)\\n continue\\n if restore_cfg.mode == 'latest':\\n logging.info('Restoring latest T5X checkpoint.')\\n ckpt_paths = ckpt_paths[-1:]\\n logging.info('Restoring checkpoints for path(s): %s', ckpt_paths)\\n for ckpt_path in ckpt_paths:\\n yield _restore_path(ckpt_path, restore_cfg)\\n return\\n else:\\n raise ValueError(\\n f'Unsupported checkpoint restore mode: {restore_cfg.mode}')\",\n \"def load_from_path(self, checkpoint_dir):\\n\\n vars = self.save_var_names\\n saver = tf.train.Saver(vars)\\n\\n def load_aux(ckpt_path):\\n \\\"\\\"\\\"Helper function to not repeat the same code in the following lines.\\\"\\\"\\\"\\n\\n ckpt_name = os.path.basename(ckpt_path)\\n saver.restore(self.sess, ckpt_path)\\n counter = int(next(re.finditer(\\\"(\\\\d+)(?!.*\\\\d)\\\", ckpt_name)).group(0))\\n self.counter = counter\\n print(\\\" [*] Loaded {}\\\".format(ckpt_name))\\n return True, counter\\n\\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\\n try:\\n if ckpt and ckpt.model_checkpoint_path:\\n ckpt_name = os.path.basename(ckpt.model_checkpoint_path)\\n return load_aux(os.path.join(checkpoint_dir, ckpt_name))\\n else:\\n print(\\n \\\" [!] Failed to find a checkpoint within directory {}\\\".format(\\n FLAGS.ckpt_path))\\n return False, 0\\n except:\\n print(\\\" [!] Failed to find a checkpoint, Exception!\\\")\\n return False, 0\",\n \"def define_model_and_optimizer(self):\\r\\n print(\\\"* Defining model and optimizer.\\\", flush=True)\\r\\n job_dir = self.C.job_dir\\r\\n\\r\\n if self.C.restart:\\r\\n print(\\\"-- Loading model from previous saved state.\\\", flush=True)\\r\\n self.restart_epoch = util.get_restart_epoch()\\r\\n self.model = torch.load(f\\\"{job_dir}model_restart_{self.restart_epoch}.pth\\\")\\r\\n\\r\\n print(\\r\\n f\\\"-- Backing up as \\\"\\r\\n f\\\"{job_dir}model_restart_{self.restart_epoch}_restarted.pth.\\\",\\r\\n flush=True,\\r\\n )\\r\\n shutil.copyfile(\\r\\n f\\\"{job_dir}model_restart_{self.restart_epoch}.pth\\\",\\r\\n f\\\"{job_dir}model_restart_{self.restart_epoch}_restarted.pth\\\",\\r\\n )\\r\\n\\r\\n else:\\r\\n print(\\\"-- Initializing model from scratch.\\\", flush=True)\\r\\n self.model = models.initialize_model()\\r\\n\\r\\n self.restart_epoch = 0\\r\\n\\r\\n start_epoch = self.restart_epoch + 1\\r\\n end_epoch = start_epoch + self.C.epochs\\r\\n\\r\\n print(\\\"-- Defining optimizer.\\\", flush=True)\\r\\n self.optimizer = torch.optim.Adam(\\r\\n params=self.model.parameters(),\\r\\n lr=self.C.init_lr,\\r\\n weight_decay=self.C.weight_decay,\\r\\n )\\r\\n\\r\\n return start_epoch, end_epoch\",\n \"def load_checkpoint(self, label):\\n model_dir = os.path.join(\\n config.results_dir, config.experiment_name, 'checkpoints')\\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\\n\\n print(\\\"Loading model from {}\\\".format(model_file))\\n model_dict = torch.load(model_file)\\n\\n self.use_cuda = model_dict['use_cuda']\\n if self.use_cuda:\\n self.net.cuda()\\n\\n self.net.load_state_dict(model_dict['net_state_dict'])\",\n \"def load(cls, path):\\n print(f'load checkpoint from {path}')\\n if torch.cuda.is_available():\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\\n else:\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\\n \\n # model.flatten_parameters() # make RNN parameters contiguous\\n optimizer = resume_checkpoint['optimizer']\\n return Checkpoint(\\n model=model, \\n optimizer=optimizer,\\n epoch=resume_checkpoint['epoch'],\\n path=path\\n )\",\n \"def load_checkpoint(self, checkpoint_dir):\\r\\n\\r\\n if not os.path.exists(checkpoint_dir):\\r\\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\\r\\n\\r\\n path = os.path.join(checkpoint_dir, 'model.pt')\\r\\n self.model.load_state_dict(torch.load(path, self.device))\\r\\n self.update()\",\n \"def __init__(self, optimizer):\\n super(ShardedOptimizer, self).__init__(optimizer, name=\\\"ShardedOptimizer\\\")\",\n \"def load_checkpoint(self):\\n checkpoin_path = self.get_checkpoint_path()\\n _logger.info('Load checkpoint ignored by tuner, checkpoint path: %s', checkpoin_path)\",\n \"def _init_model(self, checkpoint_path: str) -> None:\\n # load weights\\n logger.info(f\\\"Load weights from the checkpoint {checkpoint_path}\\\")\\n checkpoint = torch.load(checkpoint_path, map_location=torch.device(\\\"cpu\\\"))\\n\\n state_dict = checkpoint[\\\"state_dict\\\"]\\n self.orig_acc = checkpoint[\\\"test_acc\\\"]\\n\\n is_pruned = (\\n next((name for name in state_dict if \\\"mask\\\" in name), None) is not None\\n )\\n\\n if is_pruned:\\n logger.info(\\\"Dummy prunning to load pruned weights\\\")\\n model_utils.dummy_pruning(self.params_all)\\n\\n model_utils.initialize_params(self.model, state_dict)\\n logger.info(\\\"Initialized weights\\\")\\n\\n # check the trained model is pruned\\n\\n if is_pruned:\\n logger.info(\\n \\\"Get masks and remove prunning reparameterization for prepare_qat\\\"\\n )\\n self.mask = model_utils.get_masks(self.model)\\n model_utils.remove_pruning_reparameterization(self.params_all)\",\n \"def create_optimizer(hparams):\\n\\n if hparams.optimizer == 'momentum':\\n optimizer = tf.train.MomentumOptimizer(\\n learning_rate=hparams.learning_rate, momentum=hparams.momentum)\\n elif hparams.optimizer == 'adam':\\n optimizer = tf.train.AdamOptimizer(\\n learning_rate=hparams.learning_rate)\\n elif hparams.optimizer == 'adadelta':\\n optimizer = tf.train.AdadeltaOptimizer(\\n hparams.learning_rate)\\n elif hparams.optimizer == 'adagrad':\\n optimizer = tf.train.AdagradOptimizer(\\n hparams.learning_rate)\\n elif hparams.optimizer == 'rmsprop':\\n optimizer = tf.train.RMSPropOptimizer(\\n hparams.learning_rate, momentum=hparams.momentum)\\n\\n return optimizer\",\n \"def load_model (checkpoint_path, model, opt_fn=None, loss_fn=None, epoch=None):\\n\\n if not os.path.exists(checkpoint_path):\\n raise Exception (\\\"The {} does not exist!\\\".format(checkpoint_path))\\n\\n ckpt = torch.load(checkpoint_path)\\n model.load_state_dict(ckpt['model_state_dict'])\\n\\n if opt_fn is not None and loss_fn is not None:\\n opt_fn.load_state_dict(ckpt['optimizer_state_dict'])\\n epoch = ckpt['epoch']\\n loss_fn = ckpt['loss']\\n return model, opt_fn, loss_fn, epoch\\n else:\\n return model\",\n \"def _get_init_fn():\\n if FLAGS.checkpoint_path is None:\\n return None\\n\\n # Warn the user if a checkpoint exists in the train_dir. Then we'll be\\n # ignoring the checkpoint anyway.\\n if tf.train.latest_checkpoint(FLAGS.train_dir):\\n tf.logging.info(\\n 'Ignoring --checkpoint_path because a checkpoint already exists in %s'\\n % FLAGS.train_dir)\\n return None\\n\\n exclusions = []\\n if FLAGS.checkpoint_exclude_scopes:\\n exclusions = [scope.strip()\\n for scope in FLAGS.checkpoint_exclude_scopes.split(',')]\\n\\n # TODO(sguada) variables.filter_variables()\\n variables_to_restore = []\\n for var in slim.get_model_variables():\\n excluded = False\\n for exclusion in exclusions:\\n if var.op.name.startswith(exclusion):\\n excluded = True\\n break\\n if not excluded:\\n variables_to_restore.append(var)\\n\\n if tf.gfile.IsDirectory(FLAGS.checkpoint_path):\\n checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)\\n else:\\n checkpoint_path = FLAGS.checkpoint_path\\n\\n tf.logging.info('Fine-tuning from %s' % checkpoint_path)\\n\\n return slim.assign_from_checkpoint_fn(\\n checkpoint_path,\\n variables_to_restore,\\n ignore_missing_vars=FLAGS.ignore_missing_vars)\",\n \"def _get_init_fn():\\n if FLAGS.checkpoint_path is None:\\n return None\\n\\n # Warn the user if a checkpoint exists in the train_dir. Then we'll be\\n # ignoring the checkpoint anyway.\\n if tf.train.latest_checkpoint(FLAGS.train_dir):\\n tf.logging.info(\\n 'Ignoring --checkpoint_path because a checkpoint already exists in %s'\\n % FLAGS.train_dir)\\n return None\\n\\n exclusions = []\\n if FLAGS.checkpoint_exclude_scopes:\\n exclusions = [scope.strip()\\n for scope in FLAGS.checkpoint_exclude_scopes.split(',')]\\n\\n # TODO(sguada) variables.filter_variables()\\n variables_to_restore = []\\n for var in slim.get_model_variables():\\n excluded = False\\n for exclusion in exclusions:\\n if var.op.name.startswith(exclusion):\\n excluded = True\\n break\\n if not excluded:\\n variables_to_restore.append(var)\\n\\n if tf.gfile.IsDirectory(FLAGS.checkpoint_path):\\n checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)\\n else:\\n checkpoint_path = FLAGS.checkpoint_path\\n\\n tf.logging.info('Fine-tuning from %s' % checkpoint_path)\\n\\n return slim.assign_from_checkpoint_fn(\\n checkpoint_path,\\n variables_to_restore,\\n ignore_missing_vars=FLAGS.ignore_missing_vars)\",\n \"def maybe_load_model(name, split_num, checkpoint_dir, resume_from_epoch,\\n batch_norm, l1_factor, l2_factor, optimizer):\\n basename = get_basename(name, split_num)\\n model_filename_fmt = get_model_filename_fmt(basename)\\n model_filename = model_filename_fmt.format(epoch=resume_from_epoch)\\n\\n checkpoint_path = os.path.join(checkpoint_dir, model_filename)\\n\\n if resume_from_epoch > 0 and os.path.isfile(checkpoint_path):\\n\\n click.secho(f\\\"Found model checkpoint '{checkpoint_path}'. \\\"\\n f\\\"Resuming from epoch {resume_from_epoch}.\\\", fg='green')\\n\\n model = load_model(checkpoint_path)\\n\\n initial_epoch = resume_from_epoch\\n\\n else:\\n\\n click.secho(f\\\"Could not load model checkpoint '{checkpoint_path}' \\\"\\n \\\"or `resume_from_epoch == 0`. Building new model.\\\",\\n fg='yellow')\\n\\n model = build_model(output_dim=1, batch_norm=batch_norm,\\n kernel_regularizer=l1_l2(l1_factor, l2_factor))\\n # optimizer = Adam(beta_1=0.5)\\n model.compile(loss='binary_crossentropy', optimizer=optimizer,\\n metrics=['accuracy'])\\n\\n initial_epoch = 0\\n\\n return model, initial_epoch\",\n \"def resume(model, optimizer, gpu, filepath='./saves/checkpoint.pth.tar'):\\n assert isinstance(filepath, str)\\n\\n if gpu:\\n f = torch.load(filepath)\\n else:\\n f = torch.load(filepath, map_location=lambda storage, loc: storage)\\n epoch = f['epoch']\\n losses = f['losses']\\n seq_len = f['seq_len']\\n\\n model.load_state_dict(f['state_dict'])\\n optimizer.load_state_dict(f['optimizer'])\\n return model, optimizer, epoch, losses, seq_len\",\n \"def load_from_checkpoint(results_dir, load_fn, args):\\n ckpt_dir = os.path.join(results_dir, \\\"tb\\\", \\\"version_0\\\", \\\"checkpoints\\\")\\n files = os.listdir(ckpt_dir)\\n assert len(files) > 0, \\\"Checkpoint directory is empty\\\"\\n ckpt_path = os.path.join(ckpt_dir, files[-1])\\n model = load_fn(checkpoint_path=ckpt_path, args=args)\\n return model\",\n \"def init_optimizer(model, config, exact_layers=None):\\n opt_type = config.optimizer\\n if exact_layers:\\n logger.info('Learning exact layers, number=%d', len(exact_layers))\\n parameters = []\\n for i, layer in enumerate(exact_layers):\\n if isinstance(layer, tuple) and len(layer) == 2:\\n layer, multiplier = layer\\n init_multiplier = 1\\n elif isinstance(layer, tuple) and len(layer) == 3:\\n layer, init_multiplier, multiplier = layer\\n else:\\n multiplier = 1\\n init_multiplier = 1\\n lr = config.lr * multiplier\\n init_lr = config.lr * multiplier * init_multiplier\\n logger.info('Layer=%d, lr=%.5f', i, init_lr)\\n parameters.append({'params': layer.parameters(), 'lr': init_lr, 'after_warmup_lr': lr})\\n else:\\n logger.info('Optimizing all parameters, lr=%.5f', config.lr)\\n parameters = model.parameters()\\n\\n if opt_type == 'sgd':\\n optimizer = torch.optim.SGD(parameters, config.lr, momentum=config.momentum, weight_decay=config.weight_decay)\\n elif opt_type == 'adam':\\n optimizer = torch.optim.Adam(parameters, lr=config.lr, weight_decay=config.weight_decay)\\n elif opt_type == 'yf':\\n optimizer = YFOptimizer(parameters, config.lr, mu=config.momentum, weight_decay=config.weight_decay,\\n clip_thresh=0.1)\\n else:\\n raise TypeError, 'Unknown optimizer type=%s' % (opt_type, )\\n return optimizer\",\n \"def load_checkpoint(self, session, model_dir):\\n assert self.params.cp_load == True, (\\\"cp_load must be set to true to load a checkpoint\\\")\\n self.loader.restore(session, model_dir)\",\n \"def load_checkpoint(filepath):\\n checkpoint = torch.load(filepath)\\n \\n arch = checkpoint['arch']\\n if arch == 'vgg':\\n model = models.vgg16(pretrained=True)\\n elif arch == 'densenet':\\n model = models.densenet121(pretrained=True) \\n \\n model.class_to_idx = checkpoint['class_to_idx']\\n model.classifier = checkpoint['classifier']\\n model.classifier.load_sate_dict = checkpoint['classifier_state_dict']\\n model.optimizer = checkpoint['optimizer_state_dict']\\n model.input_size = checkpoint['input_size']\\n model.output_size = checkpoint['output_size']\\n \\n return model\",\n \"def state_create(recipe, stage, devtype):\\n\\n # subsequent `.load_state_dict()` automatically moves to device and casts\\n # `model` stage in a stage are allowed to be None\\n model = get_model(recipe, **stage[\\\"model\\\"]).to(**devtype)\\n\\n # base lr is specified in the optimizer settings\\n optim = get_optimizer(model, stage[\\\"optimizer\\\"])\\n\\n # name-id mapping for copying optimizer states\\n mapper = {k: id(p) for k, p in model.named_parameters()}\\n\\n return State(model, optim, mapper)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7107619","0.70649505","0.7064646","0.69969","0.6977983","0.6892563","0.6793151","0.67687976","0.673699","0.6716268","0.65814966","0.650589","0.64456534","0.64456534","0.6368876","0.632732","0.6312547","0.6301847","0.62795025","0.6267788","0.623797","0.61970675","0.6188866","0.6160548","0.61562544","0.61470646","0.61243194","0.6072098","0.6072091","0.6048436","0.6034581","0.60323876","0.6016112","0.6015076","0.6009018","0.6002419","0.5990809","0.5974894","0.59277564","0.59171706","0.59171706","0.5892049","0.5838952","0.5836216","0.5823521","0.58004516","0.57544154","0.57544154","0.5753728","0.57502097","0.5740976","0.5733053","0.57278365","0.57276464","0.57227236","0.5707192","0.56827104","0.56801975","0.5676075","0.5670331","0.56604284","0.56260026","0.5621544","0.56213075","0.56176025","0.5612432","0.56096023","0.56047535","0.55953526","0.5592341","0.5589361","0.5583856","0.5582378","0.55680716","0.55661315","0.5561057","0.55473334","0.55380076","0.5526939","0.55258477","0.55244076","0.5524308","0.5519089","0.5508652","0.55036366","0.5496245","0.5490582","0.5490566","0.5476506","0.5473886","0.54663295","0.54622054","0.54600763","0.5450367","0.5446924","0.5446162","0.54386723","0.54309535","0.5416919","0.5414193"],"string":"[\n \"0.7107619\",\n \"0.70649505\",\n \"0.7064646\",\n \"0.69969\",\n \"0.6977983\",\n \"0.6892563\",\n \"0.6793151\",\n \"0.67687976\",\n \"0.673699\",\n \"0.6716268\",\n \"0.65814966\",\n \"0.650589\",\n \"0.64456534\",\n \"0.64456534\",\n \"0.6368876\",\n \"0.632732\",\n \"0.6312547\",\n \"0.6301847\",\n \"0.62795025\",\n \"0.6267788\",\n \"0.623797\",\n \"0.61970675\",\n \"0.6188866\",\n \"0.6160548\",\n \"0.61562544\",\n \"0.61470646\",\n \"0.61243194\",\n \"0.6072098\",\n \"0.6072091\",\n \"0.6048436\",\n \"0.6034581\",\n \"0.60323876\",\n \"0.6016112\",\n \"0.6015076\",\n \"0.6009018\",\n \"0.6002419\",\n \"0.5990809\",\n \"0.5974894\",\n \"0.59277564\",\n \"0.59171706\",\n \"0.59171706\",\n \"0.5892049\",\n \"0.5838952\",\n \"0.5836216\",\n \"0.5823521\",\n \"0.58004516\",\n \"0.57544154\",\n \"0.57544154\",\n \"0.5753728\",\n \"0.57502097\",\n \"0.5740976\",\n \"0.5733053\",\n \"0.57278365\",\n \"0.57276464\",\n \"0.57227236\",\n \"0.5707192\",\n \"0.56827104\",\n \"0.56801975\",\n \"0.5676075\",\n \"0.5670331\",\n \"0.56604284\",\n \"0.56260026\",\n \"0.5621544\",\n \"0.56213075\",\n \"0.56176025\",\n \"0.5612432\",\n \"0.56096023\",\n \"0.56047535\",\n \"0.55953526\",\n \"0.5592341\",\n \"0.5589361\",\n \"0.5583856\",\n \"0.5582378\",\n \"0.55680716\",\n \"0.55661315\",\n \"0.5561057\",\n \"0.55473334\",\n \"0.55380076\",\n \"0.5526939\",\n \"0.55258477\",\n \"0.55244076\",\n \"0.5524308\",\n \"0.5519089\",\n \"0.5508652\",\n \"0.55036366\",\n \"0.5496245\",\n \"0.5490582\",\n \"0.5490566\",\n \"0.5476506\",\n \"0.5473886\",\n \"0.54663295\",\n \"0.54622054\",\n \"0.54600763\",\n \"0.5450367\",\n \"0.5446924\",\n \"0.5446162\",\n \"0.54386723\",\n \"0.54309535\",\n \"0.5416919\",\n \"0.5414193\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71238905"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4482,"cells":{"query":{"kind":"string","value":"Saves a checkpoint of the current model and optimizer_type parameters in the specified folder and uploads it to the output blob storage of the current run context. The checkpoint's name for epoch 123 would be 123_checkpoint.pth.tar."},"document":{"kind":"string","value":"def save_checkpoint(self, epoch: int) -> Path:\n logging.getLogger().disabled = True\n model_state_dict = self.model.module.state_dict() \\\n if isinstance(self.model, torch.nn.DataParallel) else self.model.state_dict()\n checkpoint_file_path = self.config.get_path_to_checkpoint(epoch)\n checkpoint_file_path.parent.mkdir(exist_ok=True, parents=True)\n info_to_store = {\n ModelAndInfo.EPOCH_KEY: epoch,\n ModelAndInfo.MODEL_STATE_DICT_KEY: model_state_dict,\n ModelAndInfo.OPTIMIZER_STATE_DICT_KEY: self.optimizer.state_dict()\n }\n if self.config.compute_mean_teacher_model:\n assert self.mean_teacher_model is not None # for mypy, getter has this built in\n mean_teacher_model_state_dict = self.mean_teacher_model.module.state_dict() \\\n if isinstance(self.mean_teacher_model, torch.nn.DataParallel) \\\n else self.mean_teacher_model.state_dict()\n info_to_store[ModelAndInfo.MEAN_TEACHER_STATE_DICT_KEY] = mean_teacher_model_state_dict\n\n torch.save(info_to_store, checkpoint_file_path)\n logging.getLogger().disabled = False\n logging.info(f\"Saved model checkpoint for epoch {epoch} to {checkpoint_file_path}\")\n return checkpoint_file_path"},"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 _save_checkpoint(checkpoint, model_dir, checkpoint_prefix):\n\n checkpoint_path = os.path.join(model_dir, checkpoint_prefix)\n saved_path = checkpoint.save(checkpoint_path)\n logging.info('Saving model as TF checkpoint: %s', saved_path)\n return","def save_checkpoint(checkpoint_dir, epoch, iteration, save_dict):\n os.makedirs(checkpoint_dir, exist_ok=True)\n path = opj(checkpoint_dir, str(epoch) + '.' + str(iteration) + '.ckpt')\n assert epoch == save_dict['epoch'], \"`epoch` != save_dict's `start_epoch`\"\n assert iteration == save_dict['iteration'], \"`iteration` != save_dict's `start_iteration`\"\n if os.path.isfile(path):\n print(\"Overwrite checkpoint in epoch %d, iteration %d :exclamation:\" % (epoch, iteration))\n try:\n torch.save(save_dict, path)\n except Exception:\n raise Exception(\"Fail to save checkpoint\")\n \n print(\"Checkpoint %s saved :heavy_check_mark:\" % (str(epoch) + '.' + str(iteration) + '.ckpt'))","def save_checkpoint(ckpt_dir, model, optim, scheduler, epoch, global_step):\n states = {\n 'model': model.state_dict(),\n 'optim': optim.state_dict(),\n 'epoch': epoch,\n 'global_step': global_step\n }\n if scheduler is not None:\n states['scheduler'] = scheduler.state_dict()\n ckpt_path = os.path.join(ckpt_dir, '[ep-{:02d}]giter-{}.ckpt'.format(epoch, global_step))\n torch.save(states, ckpt_path)\n\n return ckpt_path","def save(self, checkpoint_dir, step):\n model_name = \"CNN.model\"\n model_dir = \"%s\" % (\"cnn\")\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir)\n \n if not os.path.exists(checkpoint_dir):\n os.makedirs(checkpoint_dir)\n \n self.saver.save(self.sess,\n os.path.join(checkpoint_dir, model_name),\n global_step=step)","def save_checkpoint(self, checkpoint_dir):\r\n\r\n if not os.path.exists(checkpoint_dir):\r\n os.makedirs(checkpoint_dir)\r\n\r\n path = os.path.join(checkpoint_dir, 'model.pt')\r\n torch.save(self.model.state_dict(), path)","def save_model_checkpoint(model, optimizer, global_step, epoch_info, file_name):\n output = {\n \"model\" : model.state_dict(),\n \"optimizer\" : optimizer.state_dict(),\n \"global_step\" : global_step + 1,\n \"epoch_info\" : epoch_info\n }\n torch.save(output, file_name)","def save_checkpoint(args,state, is_best, filename=\"checkpoint.pth.tar\"):\n directory = \"runs/%s-net/\" % (args.name)\n\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n\n epoch = state['epoch']\n\n filename = directory + filename\n torch.save(state, filename)\n\n if is_best:\n shutil.copyfile(filename, \"runs/%s-net/\" % (args.name) + \"model_best.pth.tar\")\n\n if epoch==0 or epoch==2:\n shutil.copyfile(filename, \"runs/%s-net/\" % (args.name) + \"model_epoch_%d.pth.tar\" % epoch )","def save_model(self, checkpoint_path, epoch):\n self.saver.save(self.sess, checkpoint_path, global_step = epoch)","def save_checkpoint(state, is_best, epoch, args, filename='checkpoint.pth'):\n if not os.path.exists(args.save_folder):\n os.makedirs(args.save_folder)\n filename = args.save_folder + str(epoch) + '_' + filename\n torch.save(state, filename)\n if is_best:\n shutil.copyfile(filename, args.save_folder + 'model_best.pth')","def save_checkpoint(model, epoch, checkpoint_dir, stats):\n state = {\n \"epoch\": epoch,\n \"state_dict\": model.state_dict(),\n \"stats\": stats,\n }\n\n filename = os.path.join(checkpoint_dir, \"epoch={}.checkpoint.pth.tar\".format(epoch))\n torch.save(state, filename)","def save(self, epoch=None, note=None):\n\n checkpoint_encoder = {\n 'type': \"transformer\",\n 'model': self.model.encoder.state_dict(),\n 'epoch': epoch,\n 'settings': self.opt\n }\n\n if checkpoint_encoder['settings'].telegram:\n del checkpoint_encoder['settings'].telegram\n\n checkpoint_decoder = {\n 'type': \"transformer\",\n 'model': self.model.decoder.state_dict(),\n 'generator': self.model.generator.state_dict(),\n 'epoch': epoch,\n 'settings': self.opt\n }\n\n if checkpoint_decoder['settings'].telegram:\n del checkpoint_decoder['settings'].telegram\n\n if not note:\n note = \"\"\n\n # make sure a path is specified prior to saving the files.\n if self.opt.save_model:\n ready_to_save = False\n if self.opt.save_mode == \"all\":\n model_name = \"_\" + str(note)\n ready_to_save = True\n else:\n # assumes self.opt.save_mode = \"best\"\n if self.valid_accs[-1] >= max(self.valid_accs):\n model_name = \"\"\n ready_to_save = True\n if self.opt.verbose:\n print(\n ' - [Info] The checkpoint file has been updated.')\n if ready_to_save:\n encoder_name = \"encoder\" + model_name + \".chkpt\"\n decoder_name = \"decoder\" + model_name + \".chkpt\"\n # setup directory to save this at.\n encoder_filepath = os.path.join(\n self.opt.directory, encoder_name)\n decoder_filepath = os.path.join(\n self.opt.directory, decoder_name)\n torch.save(checkpoint_encoder, encoder_filepath)\n torch.save(checkpoint_decoder, decoder_filepath)\n else:\n if not self.save_trip:\n if self.opt.verbose:\n print(\n \" - [Warning]: the model is not specified to save.\")\n self.save_trip = True","def checkpoint_save(self, epoch, model, label=None, checkpoint=None, path=\"\"):\n\n if label is None:\n label = f\"checkpoint-{epoch}\"\n else:\n label = f\"{label}-checkpoint-{epoch}\"\n\n if checkpoint is None:\n pass\n elif checkpoint == -1:\n Potentials.save(model=model, label=label, path=path)\n elif epoch % checkpoint == 0:\n Potentials.save(model=model, label=label, path=path)","def save_checkpoint(self):\n \n if not os.path.isdir(self.path + '/checkpoint/'):\n os.makedirs(self.path + '/checkpoint/')\n\n if self.saver == None:\n with self.graph.as_default():\n self.saver = tf.train.Saver(tf.global_variables())\n\n self.saver.save(self.session, self.path + '/checkpoint/model.ckpt')","def save_checkpoint(self, model_path=None):\n # TODO: include new params based on ConfigEnum\n if not os.path.isdir(path_checkpoints_dir):\n os.mkdir(path_checkpoints_dir)\n if model_path is None:\n model_path = os.path.join(path_checkpoints_dir, f\"{self.experiment_id}.pth\")\n print(f\"saved the model at {model_path}\") \n model_state_dict = self.model.state_dict()\n if self.optimizer is not None:\n opt_state_dict = self.optimizer.state_dict()\n else:\n opt_state_dict = None\n if self.scheduler is not None:\n sch_state_dict = self.scheduler.state_dict()\n else:\n sch_state_dict = None\n \n if self.scaler is not None:\n amp_grad_scaler = self.scaler.state_dict()\n else:\n amp_grad_scaler = None\n\n model_dict = {}\n model_dict[\"state_dict\"] = model_state_dict\n model_dict[\"optimizer\"] = opt_state_dict\n model_dict[\"scheduler\"] = sch_state_dict\n model_dict['scaler'] = amp_grad_scaler\n model_dict['image_size'] = self.image_size\n model_dict['device'] = self.device\n model_dict['fp16'] = self.fp16\n model_dict['accumulate_grad_steps'] = self.accumulate_grad_steps\n\n model_dict['experiment_id'] = self.experiment_id\n model_dict['experiment_tag'] = self.experiment_tag\n\n model_dict['seed'] = self.seed\n\n model_dict['train_batch_size'] = self.train_batch_size\n model_dict['valid_batch_size'] = self.valid_batch_size\n model_dict['test_batch_size'] = self.test_batch_size\n model_dict['dataloader_num_workers'] = self.dataloader_num_workers\n model_dict['train_dataloader_shuffle'] = self.train_dataloader_shuffle\n\n model_dict['optimizer_type'] = self.optimizer_type\n model_dict['optimizer_params'] = self.optimizer_params\n\n model_dict['scheduler_type'] = self.scheduler_type\n model_dict['scheduler_params'] = self.scheduler_params\n model_dict['step_scheduler_after'] = self.step_scheduler_after\n model_dict['step_scheduler_metric'] = self.step_scheduler_metric\n\n model_dict['compute_train_loss_after'] = self.compute_train_loss_after\n model_dict['compute_train_metric_after'] = self.compute_train_metric_after\n model_dict['compute_valid_loss_after'] = self.compute_valid_loss_after\n model_dict['compute_valid_metric_after'] = self.compute_valid_metric_after\n\n model_dict['training_stopping_criteria'] = self.training_stopping_criteria\n model_dict['stopping_criteria_params'] = self.stopping_criteria_params\n model_dict['max_epoch'] = self.max_epoch\n model_dict['train_on_all_data'] = self.train_on_all_data\n model_dict['validate_after'] = self.validate_after\n model_dict['validation_steps'] = self.validation_steps\n model_dict['run_lr_range_test'] = self.run_lr_range_test\n model_dict['sleep_in_epochs'] = self.sleep_in_epochs\n model_dict['sleep_time'] = self.sleep_time\n model_dict['checkpoint_epochs'] = self.checkpoint_epochs\n\n model_dict['_best_score'] = self._best_score\n model_dict['_current_score'] = self._current_score\n model_dict['_counter'] = self._counter\n\n model_dict['metrics'] = self.metrics\n model_dict['current_epoch'] = self.current_epoch\n model_dict['current_train_batch'] = self.current_train_batch\n model_dict['current_valid_batch'] = self.current_valid_batch\n\n model_dict['num_train_samples'] = self.num_train_samples\n model_dict['num_train_iterations'] = self.num_train_iterations\n model_dict['checkpoint_snapshot'] = self.checkpoint_snapshot \n torch.save(model_dict, model_path)","def save_checkpoint(tag, params, model):\r\n os.makedirs(os.path.join(\"saved_models\", params.path), exist_ok=True)\r\n state = {\r\n 'training_id': params.training_id,\r\n 'global_step': model.global_step,\r\n 'model': model.state_dict(),\r\n 'optimizers': [optimizer.state_dict() for optimizer in model.optimizers]\r\n }\r\n fn = os.path.join(\"saved_models\", params.path, tag + \".pt\")\r\n torch.save(state, fn)","def save_checkpoint(self, model, optimizers):\n\n def _save(path, model, optimizers):\n if not os.path.exists(path):\n os.makedirs(path)\n # TODO: put everything on CPU first\n torch.save(model.state_dict(), os.path.join(path, 'model.ckpt'))\n torch.save(tuple([optimizer.opt.state_dict() for optimizer in optimizers]),\n os.path.join(path, 'opt.ckpt'))\n\n if (self.epoch % self._save_iter) == 0:\n # we're at a save iteration\n ckpt_path = os.path.join(self.log_path, 'checkpoints', str(self.epoch))\n _save(ckpt_path, model, optimizers)\n\n if self._best_epoch:\n # overwrite the best model\n ckpt_path = os.path.join(self.log_path, 'checkpoints', 'best')\n _save(ckpt_path, model, optimizers)\n self._best_epoch = False","def save_checkpoint(model, path):\n\n model_name = path.split('-')[0]\n assert (model_name in ['vgg16', 'resnet50'\n ]), \"Path must have the correct model name\"\n\n # Basic details\n checkpoint = {\n 'class_to_idx': model.class_to_idx,\n 'idx_to_class': model.idx_to_class,\n 'epochs': model.epochs,\n }\n\n # Extract the final classifier and the state dictionary\n if model_name == 'vgg16':\n # Check to see if model was parallelized\n if multi_gpu:\n checkpoint['classifier'] = model.module.classifier\n checkpoint['state_dict'] = model.module.state_dict()\n else:\n checkpoint['classifier'] = model.classifier\n checkpoint['state_dict'] = model.state_dict()\n\n elif model_name == 'resnet50':\n if multi_gpu:\n checkpoint['fc'] = model.module.fc\n checkpoint['state_dict'] = model.module.state_dict()\n else:\n checkpoint['fc'] = model.fc\n checkpoint['state_dict'] = model.state_dict()\n\n # Add the optimizer\n checkpoint['optimizer'] = model.optimizer\n checkpoint['optimizer_state_dict'] = model.optimizer.state_dict()\n\n # Save the data to the path\n torch.save(checkpoint, path)","def save_model_checkpoint(base_name, model, ep, opt):\n # Save only the model params\n model_name = os.path.join(base_name, \"i3d_ep\"+str(ep)+\"_\"+opt+\".pt\")\n\n torch.save(model.state_dict(), model_name)\n print(\"Model saved to disk... : {}\".format(model_name))","def save(self, experiment_dir):\n date_time = time.strftime('%Y_%m_%d_%H_%M_%S', time.localtime())\n\n if self.eval_results is not None:\n # print(self.eval_results)\n assert isinstance(self.eval_results, dict)\n # present the dict in str form\n # res_str = ''.join(''.join(str(x) for x in tup) for tup in self.eval_results.items())\n\n self._path = os.path.join(\n experiment_dir, self.CHECKPOINT_DIR_NAME, date_time,\n )\n path = self._path\n\n if os.path.exists(path):\n shutil.rmtree(path)\n os.makedirs(path)\n\n torch.save(\n {'epoch': self.epoch, 'optimizer': self.optimizer},\n os.path.join(path, self.TRAINER_STATE_NAME)\n )\n torch.save(self.model, os.path.join(path, self.MODEL_NAME))\n\n # save parameters to txt\n txt_file = open(os.path.join(path, self.PARAMETERS), \"w\")\n\n txt_file.write(f\"ckpt name: '{date_time}'\\n\")\n txt_file.write(f\"epoch: {self.epoch}\\n\")\n\n if self.eval_results is not None: \n for key, value in self.eval_results.items():\n txt_file.write(str(key)+': '+str(value)+'\\n')\n # if 'acc' in self.eval_results:\n # txt_file.write(f\"acc: {self.eval_results['acc']}\\n\")\n # if 'p' in self.eval_results:\n # txt_file.write(f\"p: {self.eval_results['p']}\\n\")\n # if 'r' in self.eval_results:\n # txt_file.write(f\"r: {self.eval_results['r']}\\n\")\n # if 'f1' in self.eval_results:\n # txt_file.write(f\"f1: {self.eval_results['f1']}\\n\")\n \n txt_file.close()\n\n return path","def save_checkpoint(self, label):\n model_dir = os.path.join(\n config.results_dir, config.experiment_name, 'checkpoints')\n os.makedirs(model_dir, exist_ok=True)\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\n\n model_dict = {'net_state_dict': self.net.state_dict(),\n 'use_cuda': self.use_cuda}\n\n print(\"Saving model to {}\".format(model_file))\n torch.save(model_dict, model_file)","def save_checkpoint(self, name=''):\n self.checkpoint_path.mkdir(exist_ok=True)\n if name:\n path = self.checkpoint_path / f'{name}_{self.epoch}.tar'\n else:\n path = self.checkpoint_path / f'{self.epoch}.tar'\n torch.save(self.get_state(), path)","def save(self, checkpoint_dir, step):\n\n model_name = \"CSGAN.model\"\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n\n if not os.path.exists(checkpoint_dir):\n os.makedirs(checkpoint_dir)\n\n self.saver.save(self.sess, os.path.join(checkpoint_dir, model_name), global_step=step)","def save_checkpoint(self, folder='checkpoint', filename='checkpoint.pth.tar'):\n data = dict()\n data[\"inst\"] = \"save\"\n data[\"folder\"] = folder\n data[\"filename\"] = filename\n\n q_idx, data_id = self.put(data, q_idx=0) # Send instruction to first nnet\n self.get(q_idx, data_id) # Blocks here\n\n # Done","def save_checkpoint(model, state, is_best, checkpoint):\n state_filepath = os.path.join(checkpoint, 'last.pth.tar')\n model_filepath = os.path.join(checkpoint, 'last_model.pth')\n if not os.path.exists(checkpoint):\n print(\"Checkpoint Directory does not exist! Making directory {}\".format(checkpoint))\n os.mkdir(checkpoint)\n else:\n print(\"Checkpoint Directory exists! \")\n torch.save(state, state_filepath)\n torch.save(model, model_filepath)\n if is_best:\n shutil.copyfile(state_filepath, os.path.join(checkpoint, 'best.pth.tar'))\n shutil.copyfile(model_filepath, os.path.join(checkpoint, 'best_model.pth'))","def saveCheckpoint(acc, epoch, model, train_hist):\r\n print('Saving..')\r\n state = {\r\n 'model': model,\r\n 'acc': acc,\r\n 'epoch': epoch,\r\n 'rng_state': torch.get_rng_state(),\r\n 'train_hist': train_hist\r\n }\r\n if not os.path.isdir('checkpoint'): # save to checkpoint directory\r\n os.mkdir('checkpoint')\r\n torch.save(state, './checkpoint/ckpt' + '_' + str(epoch+1))","def save_checkpoint(dir, state, is_best, filename='checkpoint.pth.tar'):\n directory = \"%s/\" % (dir)\n if not os.path.exists(directory):\n os.makedirs(directory)\n filename = directory + filename\n torch.save(state, filename)\n if is_best:\n shutil.copyfile(filename, '%s/' %\n (dir) + 'model_best.pth.tar')","def save_checkpoint(state: dict, is_best: bool, filename: str = 'checkpoint.pth.tar', args: Namespace = None):\n directory = f\"runs/{args.name}/\"\n if not os.path.exists(directory):\n os.makedirs(directory)\n filename = directory + filename\n torch.save(state, filename)\n if is_best:\n shutil.copyfile(filename, f'runs/{args.name}/model_best.pth.tar')","def save(self, checkpoint) -> None:\r\n self.model.save(checkpoint)","def _save_model(self, checkpoint_dir):\n # Check whether the specified path exists or not\n isExist = os.path.exists(checkpoint_dir)\n\n if not isExist:\n # Create a new directory because it does not exist\n os.makedirs(checkpoint_dir)\n\n filename = self._get_checkpoint_name()\n path = checkpoint_dir + filename\n\n # Serialize the model checkpoint in to a Python Pickle file\n with open(path, 'wb') as f:\n pickle.dump(self._model, f)\n return path","def _save(self, tmp_checkpoint_dir):\n checkpoint_path = os.path.join(tmp_checkpoint_dir, \"model_weights\")\n self.model.save_weights(checkpoint_path, save_format=\"tf\")\n return tmp_checkpoint_dir","def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):\n directory = \"runs/%s/\"%(args.name)\n if not os.path.exists(directory):\n os.makedirs(directory)\n filename = directory + filename\n torch.save(state, filename)\n if is_best:\n shutil.copyfile(filename, 'runs/%s/'%(args.name) + 'model_best.pth.tar')","def create_checkpoint(model, save_dir, train_data):\n model.class_to_idx = train_data.class_to_idx\n\n checkpoint = {\n 'model': model.name,\n 'classifier': model.classifier,\n 'class_to_idx': model.class_to_idx,\n 'state_dict': model.state_dict()\n }\n\n if save_dir and isdir(save_dir):\n torch.save(checkpoint, save_dir + 'checkpoint.pth')\n print('checkpoint created')\n else: \n print(\"Directory not found. Saving at current directory in checkpoint.pth\")\n torch.save(checkpoint, 'checkpoint.pth')","def save_checkpoint(epoch, outdir, model, mapper, optimizer, criterion,\n filename='checkpoint.OWE.pth.tar'):\n filename = outdir / filename\n logger.info(\"Saving checkpoint to {}.\".format(filename))\n torch.save({'epoch': epoch,\n 'model': model.state_dict(),\n 'mapper': mapper.state_dict(),\n 'optimizer': optimizer.state_dict(),\n }, str(filename))\n if max(criterion) == criterion[-1]:\n best_name = str(outdir / 'best_checkpoint.OWE.pth.tar')\n shutil.copyfile(str(filename), best_name)\n logger.info(\"Saved best checkpoint to {}.\".format(best_name))","def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):\n directory = \"runs/%s/\" % (args.name)\n if not os.path.exists(directory):\n os.makedirs(directory)\n filename = directory + filename\n torch.save(state, filename)\n if is_best:\n shutil.copyfile(filename, 'runs/%s/' % (args.name) + 'model_best.pth.tar')","def save_checkpoint(checkpoint_dir, model_encoder_noisy_clean, model_encoder_noisy_noise, model_decoder_noisy,\n model_encoder_clean, model_decoder_clean, model_encoder_noise, model_decoder_noise,\n model_classifier, min_eval_loss_melsp_y_dB, min_eval_loss_melsp_y_dB_std,\n iter_idx, min_idx, optimizer, numpy_random_state, torch_random_state, iterations, model_spkidtr=None):\n model_encoder_noisy_clean.cpu()\n model_encoder_noisy_noise.cpu()\n model_decoder_noisy.cpu()\n model_encoder_clean.cpu()\n model_decoder_clean.cpu()\n model_encoder_noise.cpu()\n model_decoder_noise.cpu()\n model_classifier.cpu()\n checkpoint = {\n \"model_encoder_noisy_clean\": model_encoder_noisy_clean.state_dict(),\n \"model_encoder_noisy_noise\": model_encoder_noisy_noise.state_dict(),\n \"model_decoder_noisy\": model_decoder_noisy.state_dict(),\n \"model_encoder_clean\": model_encoder_clean.state_dict(),\n \"model_decoder_clean\": model_decoder_clean.state_dict(),\n \"model_encoder_noise\": model_encoder_noise.state_dict(),\n \"model_decoder_noise\": model_decoder_noise.state_dict(),\n \"model_classifier\": model_classifier.state_dict(),\n \"min_eval_loss_melsp_y_dB\": min_eval_loss_melsp_y_dB,\n \"min_eval_loss_melsp_y_dB_std\": min_eval_loss_melsp_y_dB_std,\n \"iter_idx\": iter_idx,\n \"min_idx\": min_idx,\n \"optimizer\": optimizer.state_dict(),\n \"numpy_random_state\": numpy_random_state,\n \"torch_random_state\": torch_random_state,\n \"iterations\": iterations}\n if not os.path.exists(checkpoint_dir):\n os.makedirs(checkpoint_dir)\n torch.save(checkpoint, checkpoint_dir + \"/checkpoint-%d.pkl\" % iterations)\n model_encoder_noisy_clean.cuda()\n model_encoder_noisy_noise.cuda()\n model_decoder_noisy.cuda()\n model_encoder_clean.cuda()\n model_decoder_clean.cuda()\n model_encoder_noise.cuda()\n model_decoder_noise.cuda()\n model_classifier.cuda()\n logging.info(\"%d-iter checkpoint created.\" % iterations)","def save(self, checkpoint_path: str):\r\n raise NotImplementedError","def _save(trainer, checkpoint_dir, state_dict_key_name, world_rank=None):\n\n # save current model parameters as a checkpoint\n makedir(checkpoint_dir)\n checkpoint_file_name = 'checkpoint{}.ortcp'.format('' if world_rank is None else str(world_rank))\n trainer.save_checkpoint(os.path.join(checkpoint_dir, checkpoint_file_name))\n state_dict = trainer.state_dict()\n with open(os.path.join(checkpoint_dir, state_dict_key_name+'.pkl'), \"wb\") as f:\n pickle.dump({state_dict_key_name : state_dict}, f)","def save_checkpoint(self, checkpoint_path='checkpoint.pth'):\n # Move the model back to the cpu so it can be loaded onto machines\n # without gpu's as well.\n self.model.to('cpu')\n\n checkpoint = {\n 'model_architecture': self.model_architecture,\n 'input_size': self.input_size,\n 'output_size': self.output_size,\n 'hidden_layers': self.hidden_layers,\n 'learn_rate': self.learn_rate,\n 'drop_p': self.drop_p,\n 'class_to_idx': self.model.class_to_idx,\n 'current_epoch': self.model.current_epoch,\n 'optimizer_state_dict': self.optimizer.state_dict(),\n 'model_state_dict': self.model.state_dict()\n }\n torch.save(checkpoint, checkpoint_path)","def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):\n directory = \"checkoutpoint/%s/\" % args.name\n if not os.path.exists(directory):\n os.makedirs(directory)\n filename = directory + filename\n torch.save(state, filename)\n if is_best:\n shutil.copyfile(filename, 'checkoutpoint/%s/' % args.name + 'model_best.pth.tar')","def _save_model(self, epoch, batch, logs):\n self.save(self._get_file_path(epoch, batch, logs))","def save_checkpoint(state, is_best, checkpoint_dir, logger=None):\n\n def log_info(message):\n if logger is not None:\n logger.info(message)\n\n if not os.path.exists(checkpoint_dir):\n log_info(\n f\"Checkpoint directory does not exists. Creating {checkpoint_dir}\")\n os.mkdir(checkpoint_dir)\n\n last_file_path = os.path.join(checkpoint_dir, f'epoch{state[\"epoch\"]}_checkpoint.pytorch')\n log_info(f\"Saving last checkpoint to '{last_file_path}'\")\n torch.save(state, last_file_path)\n if is_best:\n best_file_path = os.path.join(checkpoint_dir, 'best_checkpoint.pytorch')\n log_info(f\"Saving best checkpoint to '{best_file_path}'\")\n shutil.copyfile(last_file_path, best_file_path)","def save(self):\n\n self.saver.save(self.sess, self.path + '/tensorflow-model', global_step=self.counter.count)","def save_checkpoint(filename, epoch, model, optimizer=None, best_score=0):\n torch.save({\n 'model' : model.state_dict(),\n 'optim' : optimizer.state_dict() if optimizer is not None else None,\n 'epoch' : epoch,\n 'best_score' : best_score\n }, filename)","def save_checkpoint(model, save_path):\n torch.save(model.state_dict(), save_path)","def save(self, model_dir, step, epoch, is_best=False):\n if model_dir is None:\n return\n save_checkpoint(self._model, self._optimizer, step, epoch, model_dir,\n keep_every_n=self._keep_every_n, is_best=is_best)","def checkpoint(self, epoch, losses, path):\n dct = {'epoch': epoch, \n 'losses': losses, \n 'model_state_dict': self.TrajectoryAutoencoder.state_dict()}\n torch.save(dct, path)","def save_checkpoint(self, checkpoint_info):\n torch.save(checkpoint_info, os.path.join(self.checkpoint_path, self.checkpoint_file))","def save_model(self, epoch):\n ckpt_path = os.path.join(self.config.save_path, f'{epoch}.pkl')\n print(f'Save parameters to {ckpt_path}')\n torch.save(self.model.state_dict(), ckpt_path)","def save_checkpoint(self):\n checkpoin_path = self.get_checkpoint_path()\n _logger.info('Save checkpoint ignored by tuner, checkpoint path: %s', checkpoin_path)","def create_checkpoint(model_config, path):\n model = models.VisionTransformer(num_classes=1, **model_config)\n variables = model.init(\n jax.random.PRNGKey(0),\n jnp.ones([1, 16, 16, 3], jnp.float32),\n train=False,\n )\n _save(variables['params'], path)","def save_checkpoint(self, checkpoint_dir: str) -> None:\n state = self.__getstate__()\n\n # Extract policy states from worker state (Policies get their own\n # checkpoint sub-dirs).\n policy_states = {}\n if \"worker\" in state and \"policy_states\" in state[\"worker\"]:\n policy_states = state[\"worker\"].pop(\"policy_states\", {})\n\n # Add RLlib checkpoint version.\n if self.config._enable_learner_api:\n state[\"checkpoint_version\"] = CHECKPOINT_VERSION_LEARNER\n else:\n state[\"checkpoint_version\"] = CHECKPOINT_VERSION\n\n # Write state (w/o policies) to disk.\n state_file = os.path.join(checkpoint_dir, \"algorithm_state.pkl\")\n with open(state_file, \"wb\") as f:\n pickle.dump(state, f)\n\n # Write rllib_checkpoint.json.\n with open(os.path.join(checkpoint_dir, \"rllib_checkpoint.json\"), \"w\") as f:\n json.dump(\n {\n \"type\": \"Algorithm\",\n \"checkpoint_version\": str(state[\"checkpoint_version\"]),\n \"format\": \"cloudpickle\",\n \"state_file\": state_file,\n \"policy_ids\": list(policy_states.keys()),\n \"ray_version\": ray.__version__,\n \"ray_commit\": ray.__commit__,\n },\n f,\n )\n\n # Write individual policies to disk, each in their own sub-directory.\n for pid, policy_state in policy_states.items():\n # From here on, disallow policyIDs that would not work as directory names.\n validate_policy_id(pid, error=True)\n policy_dir = os.path.join(checkpoint_dir, \"policies\", pid)\n os.makedirs(policy_dir, exist_ok=True)\n policy = self.get_policy(pid)\n policy.export_checkpoint(policy_dir, policy_state=policy_state)\n\n # if we are using the learner API, save the learner group state\n if self.config._enable_learner_api:\n learner_state_dir = os.path.join(checkpoint_dir, \"learner\")\n self.learner_group.save_state(learner_state_dir)","def _save_checkpoint(self, epoch, is_best=False):\n arch = type(self.model).__name__\n state = {\n 'arch': arch,\n 'epoch': epoch,\n 'state_dict': self.model.state_dict(),\n 'optimizer': self.optimizer.state_dict(),\n 'config': self.config\n }\n filename = str(self.checkpoint_dir / 'checkpoint-epoch{}.pth'.format(epoch))\n torch.save(state, filename)\n self.logger.info(\"Saving checkpoint: {} ...\".format(filename))\n if is_best:\n best_path = str(self.checkpoint_dir / 'model_best.pth')\n torch.save(state, best_path)\n self.logger.info(\"Saving current best: model_best.pth ...\")","def save_checkpoint(state, model_name=None):\n \n if not model_name: model_name = f\"model_date_{date_time_str}.pth\"\n torch.save(state, osj(out_path, model_name))","def save_checkpoint(state, is_best, checkpoint_dir, logger=None):\n\n def log_info(message):\n if logger is not None:\n logger.info(message)\n\n if not os.path.exists(checkpoint_dir):\n log_info(\n \"Checkpoint directory does not exists. Creatding {}\".format(checkpoint_dir))\n os.mkdir(checkpoint_dir)\n\n last_file_path = os.path.join(checkpoint_dir, 'last_checkpoint.pytorch')\n log_info(\"Saving last checkpoint\")\n torch.save(state, last_file_path)\n if is_best:\n best_file_path = os.path.join(checkpoint_dir, 'best_checkpoint.pytorch')\n log_info(\"Saving best checkpoint\")\n shutil.copyfile(last_file_path, best_file_path)","def save_model(self, dir=\"\", **kwargs):\n ckpt_fn = os.path.join(dir, f\"model.pkl\")\n torch.save(\n {\n \"global_step\": self.global_step_,\n \"epoch\": self.epoch_,\n \"model\": self.net_.state_dict(),\n \"optimizer\": self.optimizer_.state_dict(),\n \"sampler_state\": self.sampler.state_dict(),\n \"model_samples\": list(self.model_samples_),\n \"ais_state\": self.ais_loss.state_dict(),\n \"replay_prob\": self.replay_prob,\n \"max_replay\": self.max_replay,\n },\n ckpt_fn,\n )\n return ckpt_fn","def save_checkpoint(model, filename, optimizer=None, meta=None):\n if meta is None:\n meta = {}\n elif not isinstance(meta, dict):\n raise TypeError(f'meta must be a dict or None, but got {type(meta)}')\n meta.update(mmcv_version=mmcv.__version__, time=time.asctime())\n\n if is_module_wrapper(model):\n model = model.module\n\n if hasattr(model, 'CLASSES') and model.CLASSES is not None:\n # save class name to the meta\n meta.update(CLASSES=model.CLASSES)\n\n checkpoint = {\n 'meta': meta,\n 'state_dict': weights_to_cpu(get_state_dict(model))\n }\n # save optimizer state dict in the checkpoint\n if isinstance(optimizer, Optimizer):\n checkpoint['optimizer'] = optimizer.state_dict()\n elif isinstance(optimizer, dict):\n checkpoint['optimizer'] = {}\n for name, optim in optimizer.items():\n checkpoint['optimizer'][name] = optim.state_dict()\n\n if filename.startswith('pavi://'):\n try:\n from pavi import modelcloud\n from pavi.exception import NodeNotFoundError\n except ImportError as e:\n raise ImportError(\n 'Please install pavi to load checkpoint from modelcloud.') from e\n model_path = filename[7:]\n root = modelcloud.Folder()\n model_dir, model_name = osp.split(model_path)\n try:\n model = modelcloud.get(model_dir)\n except NodeNotFoundError:\n model = root.create_training_model(model_dir)\n with TemporaryDirectory() as tmp_dir:\n checkpoint_file = osp.join(tmp_dir, model_name)\n with open(checkpoint_file, 'wb') as f:\n torch.save(checkpoint, f)\n f.flush()\n model.create_file(checkpoint_file, name=model_name)\n else:\n mmcv.mkdir_or_exist(osp.dirname(filename))\n # immediately flush buffer\n with open(filename, 'wb') as f:\n torch.save(checkpoint, f)\n f.flush()","def save(self):\n\n if self.ckpt_manager is not None:\n save_path = self.ckpt_manager.save()\n print(\"Saved checkpoint at: {}\".format(save_path))\n else:\n print(\"There is no checkpoint manager supplied for saving the \"\n \"network weights, optimizer, or other trackables.\")\n print(\"Therefore these will not be saved and the training will \"\n \"start from default values in the future.\")\n print(\"Consider using a checkpoint manager to save the network \"\n \"weights and optimizer.\")","def save_checkpoint(filename, model, state=None):\n if not state:\n torch.save(model.state_dict(), os.path.join('checkpoints/', filename))\n else:\n _state = {\n 'epoch': state['epoch'],\n 'state_dict': state['state_dict'].state_dict(),\n 'optimizer': state['optimizer'].state_dict()\n }\n\n torch.save(_state, os.path.join('checkpoints/', filename))","def save_checkpoint(state, is_best, checkpoint_dir):\n\n if not os.path.exists(checkpoint_dir):\n os.mkdir(checkpoint_dir)\n\n last_file_path = os.path.join(checkpoint_dir, 'last_checkpoint.pytorch')\n torch.save(state, last_file_path)\n if is_best:\n best_file_path = os.path.join(checkpoint_dir, 'best_checkpoint.pytorch')\n shutil.copyfile(last_file_path, best_file_path)","def checkpoint_model(PATH, ckpt_id, model, epoch, last_global_step,\r\n last_global_data_samples, **kwargs):\r\n checkpoint_state_dict = {\r\n 'epoch': epoch,\r\n 'last_global_step': last_global_step,\r\n 'last_global_data_samples': last_global_data_samples\r\n }\r\n # Add extra kwargs too\r\n checkpoint_state_dict.update(kwargs)\r\n\r\n success = model.network.save_checkpoint(PATH, ckpt_id,\r\n checkpoint_state_dict)\r\n status_msg = 'checkpointing: PATH={}, ckpt_id={}'.format(PATH, ckpt_id)\r\n if success:\r\n logging.info(f\"Success {status_msg}\")\r\n else:\r\n logging.warning(f\"Failure {status_msg}\")\r\n return","def save_checkpoint(checkpoint_dir, model_encoder_melsp, model_decoder_melsp, model_encoder_excit, model_decoder_excit,\n model_classifier, model_post, min_eval_loss_melsp_dB, min_eval_loss_melsp_dB_std, min_eval_loss_melsp_cv,\n min_eval_loss_melsp, min_eval_loss_melsp_dB_src_trg, min_eval_loss_melsp_dB_src_trg_std, min_eval_loss_laplace,\n min_eval_loss_laplace_cv, iter_idx, min_idx, optimizer, numpy_random_state, torch_random_state,\n iterations, model_spkidtr=None):\n model_encoder_melsp.cpu()\n model_decoder_melsp.cpu()\n model_encoder_excit.cpu()\n model_decoder_excit.cpu()\n model_classifier.cpu()\n model_post.cpu()\n if model_spkidtr is not None:\n model_spkidtr.cpu()\n checkpoint = {\n \"model_encoder_melsp\": model_encoder_melsp.state_dict(),\n \"model_decoder_melsp\": model_decoder_melsp.state_dict(),\n \"model_encoder_excit\": model_encoder_excit.state_dict(),\n \"model_decoder_excit\": model_decoder_excit.state_dict(),\n \"model_classifier\": model_classifier.state_dict(),\n \"model_spkidtr\": model_spkidtr.state_dict(),\n \"model_post\": model_post.state_dict(),\n \"min_eval_loss_melsp_dB\": min_eval_loss_melsp_dB,\n \"min_eval_loss_melsp_dB_std\": min_eval_loss_melsp_dB_std,\n \"min_eval_loss_melsp_cv\": min_eval_loss_melsp_cv,\n \"min_eval_loss_melsp\": min_eval_loss_melsp,\n \"min_eval_loss_melsp_dB_src_trg\": min_eval_loss_melsp_dB_src_trg,\n \"min_eval_loss_melsp_dB_src_trg_std\": min_eval_loss_melsp_dB_src_trg_std,\n \"min_eval_loss_laplace\": min_eval_loss_laplace,\n \"min_eval_loss_laplace_cv\": min_eval_loss_laplace_cv,\n \"iter_idx\": iter_idx,\n \"min_idx\": min_idx,\n \"optimizer\": optimizer.state_dict(),\n \"numpy_random_state\": numpy_random_state,\n \"torch_random_state\": torch_random_state,\n \"iterations\": iterations}\n else:\n checkpoint = {\n \"model_encoder_melsp\": model_encoder_melsp.state_dict(),\n \"model_decoder_melsp\": model_decoder_melsp.state_dict(),\n \"model_encoder_excit\": model_encoder_excit.state_dict(),\n \"model_decoder_excit\": model_decoder_excit.state_dict(),\n \"model_classifier\": model_classifier.state_dict(),\n \"model_post\": model_post.state_dict(),\n \"min_eval_loss_melsp_dB\": min_eval_loss_melsp_dB,\n \"min_eval_loss_melsp_dB_std\": min_eval_loss_melsp_dB_std,\n \"min_eval_loss_melsp_cv\": min_eval_loss_melsp_cv,\n \"min_eval_loss_melsp\": min_eval_loss_melsp,\n \"min_eval_loss_melsp_dB_src_trg\": min_eval_loss_melsp_dB_src_trg,\n \"min_eval_loss_melsp_dB_src_trg_std\": min_eval_loss_melsp_dB_src_trg_std,\n \"min_eval_loss_laplace\": min_eval_loss_laplace,\n \"min_eval_loss_laplace_cv\": min_eval_loss_laplace_cv,\n \"iter_idx\": iter_idx,\n \"min_idx\": min_idx,\n \"optimizer\": optimizer.state_dict(),\n \"numpy_random_state\": numpy_random_state,\n \"torch_random_state\": torch_random_state,\n \"iterations\": iterations}\n if not os.path.exists(checkpoint_dir):\n os.makedirs(checkpoint_dir)\n torch.save(checkpoint, checkpoint_dir + \"/checkpoint-%d.pkl\" % iterations)\n model_encoder_melsp.cuda()\n model_decoder_melsp.cuda()\n model_encoder_excit.cuda()\n model_decoder_excit.cuda()\n model_classifier.cuda()\n model_post.cuda()\n if model_spkidtr is not None:\n model_spkidtr.cuda()\n logging.info(\"%d-iter checkpoint created.\" % iterations)","def save(self, file_prefix, options=None):\n options = options or checkpoint_options.CheckpointOptions()\n\n # IMPLEMENTATION DETAILS: most clients should skip.\n #\n # Suffix for any well-formed \"checkpoint_prefix\", when sharded.\n # Transformations:\n # * Users pass in \"save_path\" in save() and restore(). Say \"myckpt\".\n # * checkpoint_prefix gets fed <save_path><sharded_suffix>.\n #\n # Example:\n # During runtime, a temporary directory is first created, which contains\n # files\n #\n # <train dir>/myckpt_temp/\n # part-?????-of-?????{.index, .data-00000-of-00001}\n #\n # Before .save() finishes, they will be (hopefully, atomically) renamed to\n #\n # <train dir>/\n # myckpt{.index, .data-?????-of-?????}\n #\n # Filesystems with eventual consistency (such as S3), don't need a\n # temporary location. Using a temporary directory in those cases might\n # cause situations where files are not available during copy.\n #\n # Users only need to interact with the user-specified prefix, which is\n # \"<train dir>/myckpt\" in this case. Save() and Restore() work with the\n # prefix directly, instead of any physical pathname. (On failure and\n # subsequent restore, an outdated and orphaned temporary directory can be\n # safely removed.)\n with ops.device(\"CPU\"):\n sharded_suffix = array_ops.where(\n string_ops.regex_full_match(file_prefix, \"^s3://.*\"),\n constant_op.constant(\".part\"),\n constant_op.constant(\"_temp/part\"))\n tmp_checkpoint_prefix = string_ops.string_join(\n [file_prefix, sharded_suffix])\n registered_paths = {\n saver_name: registered_saver_filename(file_prefix, saver_name)\n for saver_name in self._registered_savers\n }\n\n def save_fn():\n saved_prefixes = []\n # Save with the registered savers. These run before default savers due to\n # the API contract.\n for saver_name, (save_fn, _) in self._registered_savers.items():\n maybe_saved_prefixes = save_fn(registered_paths[saver_name])\n if maybe_saved_prefixes is not None:\n flattened_saved_prefixes = nest.flatten(maybe_saved_prefixes)\n if not all(\n tensor_util.is_tf_type(x) and x.dtype == dtypes.string\n for x in flattened_saved_prefixes):\n raise ValueError(\n \"Registered saver must return a (maybe empty) list of \"\n f\"string type tensors. Got {maybe_saved_prefixes}.\")\n saved_prefixes.extend(flattened_saved_prefixes)\n\n # (Default saver) Save with single device savers.\n num_shards = len(self._single_device_savers)\n sharded_saves = []\n num_shards_tensor = constant_op.constant(num_shards, name=\"num_shards\")\n last_device = None\n for shard, (device, saver) in enumerate(\n sorted(self._single_device_savers.items())):\n last_device = device\n with ops.device(saveable_object_util.set_cpu0(device)):\n shard_prefix = sharded_filename(tmp_checkpoint_prefix, shard,\n num_shards_tensor)\n saved_prefixes.append(shard_prefix)\n with ops.device(device):\n # _SingleDeviceSaver will use the CPU device when necessary, but\n # initial read operations should be placed on the SaveableObject's\n # device.\n sharded_saves.append(saver.save(shard_prefix, options))\n\n with ops.control_dependencies(sharded_saves):\n # Merge on the io_device if specified, otherwise co-locates the merge op\n # with the last device used.\n merge_device = (\n options.experimental_io_device or\n saveable_object_util.set_cpu0(last_device))\n with ops.device(merge_device):\n # V2 format write path consists of a metadata merge step. Once\n # merged, attempts to delete the temporary directory,\n # \"<user-fed prefix>_temp\".\n return gen_io_ops.merge_v2_checkpoints(\n saved_prefixes, file_prefix, delete_old_dirs=True)\n\n # Since this will causes a function re-trace on each save, limit this to the\n # cases where it is needed: eager and when there are multiple tasks/single\n # device savers. Note that the retrace is needed to ensure we pickup the\n # latest values of options like experimental_io_device.\n if context.executing_eagerly() and len(self._single_device_savers) > 1:\n # Explicitly place the identity op on the first device.\n @def_function.function(jit_compile=False)\n def tf_function_save():\n save_fn()\n tf_function_save()\n else:\n return save_fn()","def save_model (model, folder_path, epoch, opt_fn, loss_fn, is_best, multi_gpu=False, verbose=False):\n\n last_check_path = os.path.join(folder_path, 'last-checkpoint')\n best_check_path = os.path.join(folder_path, 'best-checkpoint')\n\n if not os.path.exists(last_check_path):\n if verbose:\n print ('last-checkpoint folder does not exist. I am creating it!')\n os.mkdir(last_check_path)\n else:\n if verbose:\n print ('last-checkpoint folder exist! Perfect, I will just use it.')\n\n if not os.path.exists(best_check_path):\n if verbose:\n print('best-checkpoint folder does not exist. I am creating it!')\n os.mkdir(best_check_path)\n else:\n if verbose:\n print('best-checkpoint folder exist! Perfect, I will just use it.')\n\n info_to_save = {\n 'epoch': epoch,\n 'model_state_dict': model.module.state_dict() if multi_gpu else model.state_dict(),\n 'optimizer_state_dict': opt_fn.state_dict(),\n 'loss': loss_fn,\n }\n\n torch.save(info_to_save, os.path.join(last_check_path, \"last-checkpoint.pth\"))\n\n if is_best:\n torch.save(info_to_save, os.path.join(best_check_path, 'best-checkpoint.pth'))","def _save(self, step):\n\n output_path = self.output_path + '/checkpoints/'\n if not os.path.isdir(output_path):\n os.makedirs(output_path)\n self.saver.save(self.session, save_path=output_path,global_step=step)","def checkpoint(self, epoch: int):\n if self.exp.scheduler_stepper is not None:\n torch.save(\n {\n \"model_state_dict\": self.exp.model.state_dict(),\n \"optimizer_state_dict\": self.exp.optimizer.state_dict(),\n \"scheduler_state_dict\": self.exp.scheduler_stepper.scheduler.state_dict(),\n \"Epoch\": epoch,\n },\n self.exp.path,\n )\n else:\n torch.save(\n {\n \"model_state_dict\": self.exp.model.state_dict(),\n \"optimizer_state_dict\": self.exp.optimizer.state_dict(),\n \"Epoch\": epoch,\n },\n self.exp.path,\n )","def save_checkpoint(state, is_best, checkpoint):\n filepath = os.path.join(checkpoint, 'last.pth.tar')\n if not os.path.exists(checkpoint):\n print(\"Checkpoint Directory does not exist! Making directory {}\".format(checkpoint))\n os.mkdir(checkpoint)\n torch.save(state, filepath)\n # 如果是最好的checkpoint则以best为文件名保存\n if is_best:\n shutil.copyfile(filepath, os.path.join(checkpoint, 'best.pth.tar'))","def save(self):\n\n pattern = '{}_{}_{}ep.pt' if self.checkpoint_filename_pattern is None else self.checkpoint_filename_pattern\n filename = pattern.format('sherlock1', time.strftime(\"%Y-%m-%d_%H-%M-%S\"),\n self.monitors['loss_train'].num_epochs)\n full_filename = self.full_path(filename)\n c = {\n 'state_dict': self.net.state_dict(),\n 'optimizer': self.optimizer.state_dict(),\n 'monitors': self.monitors,\n 'parent': self.parent,\n 'args': vars(args) # convert args to dict\n }\n torch.save(c, full_filename)\n if not args.tuning and args.delete and self.last_checkpoint is not None:\n os.remove(self.last_checkpoint)\n self.last_checkpoint = full_filename\n return filename","def save_checkpoint(self, name):\n path = os.path.join(self.params.dump_path, '%s.pth' % name)\n logger.info(\"Saving %s to %s ...\" % (name, path))\n\n data = {\n 'epoch': self.epoch,\n 'best_metrics': self.scores\n }\n\n logger.warning(\"Saving model parameters ...\")\n data['model'] = self.encoder.model.state_dict()\n data['classifier'] = self.proj\n data['dico_id2word'] = self.data['dico'].id2word\n data['dico_word2id'] = self.data['dico'].word2id\n data['dico_counts'] = self.data['dico'].counts\n # print(self.encoder.pretrain_params)\n data['params'] = self.encoder.pretrain_params.update({k: v for k, v in self.params.__dict__.items()})\n\n torch.save(data, path)","def back_up(self, epoch):\n K.set_value(self._ckpt_saved_epoch, epoch)\n # Save the model plus CKPT_SAVED_EPOCH variable.\n if self.write_checkpoint_manager.save():\n distributed_file_utils.remove_temp_dirpath(\n self.write_checkpoint_manager.directory,\n None) #self._model.distribute_strategy)","def save_checkpoint(self, checkpoint: str) -> str:\n\n # Some model might need to aggregate variables during checkpointing\n # which requires both the chief and workers to participate in the\n # allreduce communication protocol.\n # So we need to call get_state on every remote workers, otherwise\n # it might get stuck\n state_refs = [w.get_state.remote() for w in self.remote_workers]\n\n state = ray.get(state_refs[0])\n\n with open(checkpoint, \"wb\") as f:\n SafePickle.dump(state, f)\n\n return checkpoint","def save_checkpoint(model, optimizer=None, model_name='model', validation_id=None):\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\n\n print_debug('Saving checkpoint: ' + path)\n\n model = model.module if type(model) is torch.nn.DataParallel else model\n\n checkpoint = {\n 'model_state_dict': model.state_dict()\n }\n\n if optimizer is not None:\n checkpoint['optimizer_state_dict'] = optimizer.state_dict()\n\n torch.save(checkpoint, path)","def saveCheckpoint(self):\n time_stamp = time.strftime('%Y%m%d%H%M%S', time.gmtime())\n state_filename = os.path.join(self.saving_dir, 'checkpoint.' + time_stamp + '.pth.tar')\n mem_filename = os.path.join(self.saving_dir, 'memory.' + time_stamp + '.pth.tar')\n state = self.getSavingState()\n memory = {\n 'memory': self.memory\n }\n torch.save(state, state_filename)\n torch.save(memory, mem_filename)","def save_checkpoint(self, path: str, **kwargs):\n if self.distributed:\n encoder = self.net_q.module.encoder\n head = self.net_q.module.head\n else:\n encoder = self.net_q.encoder\n head = self.net_q.head\n\n ckpt = {\n 'encoder': encoder.state_dict(),\n 'head': head.state_dict(),\n 'net_ps': self.net_ps.state_dict(),\n 'net_k': self.net_k.state_dict(),\n 'queue': self.queue.state_dict(),\n 'optimizer': self.optimizer.state_dict(),\n 'scheduler': self.scheduler.state_dict(),\n }\n if kwargs:\n ckpt.update(kwargs)\n torch.save(ckpt, path)","def export(self, last_checkpoint, output_dir):\r\n with tf.Session(graph=tf.Graph()) as sess:\r\n inputs, outputs = self.build_prediction_image_graph()\r\n init_op = tf.global_variables_initializer()\r\n sess.run(init_op)\r\n trained_saver = tf.train.Saver()\r\n trained_saver.restore(sess, last_checkpoint)\r\n \r\n predict_signature_def = build_signature(inputs, outputs)\r\n # Create a saver for writing SavedModel training checkpoints.\r\n build = builder.SavedModelBuilder(\r\n os.path.join(output_dir, 'saved_model_image_in'))\r\n build.add_meta_graph_and_variables(\r\n sess, [tag_constants.SERVING],\r\n signature_def_map={\r\n signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:\r\n predict_signature_def\r\n },\r\n assets_collection=tf.get_collection(tf.GraphKeys.ASSET_FILEPATHS))\r\n self.has_exported_image_in = True\r\n build.save()","def save(self, sess):\n ckpt_path = os.path.join(self.model.ckpt_dir, 'model')\n if not os.path.exists(self.model.ckpt_dir):\n os.makedirs(self.model.ckpt_dir)\n self.saver.save(sess, ckpt_path, global_step=self.gstep)","def save_folder(date_time, sfid, logs_folder, checkpoints_folder):\n date_now = str(date_time.date())\n time_now = str(date_time.time())\n sf = \"saved_models/\" + date_now + \"_\" + time_now + \"_\" \\\n + os.path.basename(__file__).split('.')[0] + '_' + sfid\n if not os.path.isdir(sf):\n os.makedirs(sf)\n\n lf = sf +'/' + logs_folder\n if not os.path.isdir(lf):\n os.makedirs(lf)\n chkf = sf +'/' +checkpoints_folder\n if not os.path.isdir(chkf):\n os.makedirs(chkf)\n\n\n return sf, lf, chkf","def save_checkpoint_manual(model: LFADS, path: str):\n model_wts = [v.numpy() for v in model.trainable_variables]\n optim_wts = model.optimizer.get_weights()\n checkpoint = {\"model\": model_wts, \"optimizer\": optim_wts}\n with open(path, \"wb\") as fout:\n pickle.dump(checkpoint, fout)","def save_checkpoint(self, name, include_optimizers=True):\n if not self.params.is_master:\n return\n path = os.path.join(self.params.dump_path, '%s.pth' % name)\n logger.info(\"Saving %s to %s ...\" % (name, path))\n\n data = {\n 'epoch': self.epoch,\n 'n_total_iter': self.n_total_iter,\n 'best_metrics': self.best_metrics,\n 'best_stopping_criterion': self.best_stopping_criterion,\n }\n\n for name in self.MODEL_NAMES:\n logger.warning(\"Saving %s parameters ...\" % name)\n data[name] = getattr(self, name).state_dict()\n if include_optimizers:\n for name in self.optimizers.keys():\n logger.warning(\"Saving %s optimizer ...\" % name)\n data['%s_optimizer' % name] = self.optimizers[name].state_dict()\n\n # data['dico_id2word'] = self.data['dico'].id2word\n # data['dico_word2id'] = self.data['dico'].word2id\n # data['dico_counts'] = self.data['dico'].counts\n data['params'] = {k: v for k, v in self.params.__dict__.items()}\n\n torch.save(data, path)","def train_and_save(self, checkpoint_dir):\n dataset = self._read_dataset(self._train_dataset_path)\n features, labels = self.get_features_and_labels(dataset)\n self._model.partial_fit(features, labels, classes=self._classes)\n checkpoint_path = self._save_model(checkpoint_dir)\n return checkpoint_path","def save_keras_checkpoint(keras_model: tf.keras.Model,\n save_path: Text,\n save_format: Text = 'ckpt'\n ):\n if save_format == 'ckpt':\n checkpoint = tf.train.Checkpoint(model=keras_model)\n manager = tf.train.CheckpointManager(checkpoint,\n directory=save_path,\n max_to_keep=1)\n manager.save()\n else:\n keras_model.save(save_path, save_format=save_format)","def write_checkpoint(self, checkpoint_id, best=False):\n assert self.output_dir is not None\n checkpoint_dir = os.path.join(self.output_dir, 'checkpoints')\n fname = self.get_model_fname(self.model)\n checkpoint_file = ''\n if best:\n checkpoint_file = 'model_checkpoint_%s.best.pth.tar' % ( fname )\n else:\n checkpoint_file = 'model_checkpoint_%s_%03i.pth.tar' % ( fname, checkpoint_id )\n os.makedirs(checkpoint_dir, exist_ok=True)\n torch.save(dict(model=self.model.state_dict()),\n os.path.join(checkpoint_dir, checkpoint_file))","def save_ckpt(self, name=None):\r\n if name is None:\r\n save_path = os.path.join(self.model_dir, \"ckpt_epoch{}.pth\".format(self.clock.epoch))\r\n print(\"Checkpoint saved at {}\".format(save_path))\r\n else:\r\n save_path = os.path.join(self.model_dir, \"{}.pth\".format(name))\r\n if isinstance(self.net, nn.DataParallel):\r\n torch.save({\r\n 'clock': self.clock.make_checkpoint(),\r\n 'model_state_dict': self.net.module.cpu().state_dict(),\r\n 'optimizer_state_dict': self.optimizer.state_dict(),\r\n 'scheduler_state_dict': self.scheduler.state_dict(),\r\n }, save_path)\r\n else:\r\n torch.save({\r\n 'clock': self.clock.make_checkpoint(),\r\n 'model_state_dict': self.net.cpu().state_dict(),\r\n 'optimizer_state_dict': self.optimizer.state_dict(),\r\n 'scheduler_state_dict': self.scheduler.state_dict(),\r\n }, save_path)\r\n self.net.cuda()","def save_model(file_name, ep, model, optimizer):\n\n torch.save({\n 'epoch': ep,\n 'model_state_dict': model.state_dict(),\n 'optimizer_state_dict': optimizer.state_dict(),\n }, file_name) \n \n return","def save_checkpoint(state, is_best, file_path, file_name='checkpoint.pth.tar'):\n\n save_path = file_path + '/' + file_name\n torch.save(state, save_path)\n if is_best:\n shutil.copyfile(save_path, file_path + '/model_best.pth.tar')","def save_model(self, path, name, epoch=\"best\"):\n\n # Checks if the save directory exists and if not creates it.\n os.makedirs(path, exist_ok=True)\n\n # Saves the model to the save directory.\n torch.save(self.state_dict(), os.path.join(path, f\"{name}_cnn_{str(epoch)}.pt\"))","def write_checkpoint(self, session):\n base_save_path = self.params.cp_save_dir+self.params.model_name+\"_v\"+self.params.version\n full_save_path = self.full_saver.save(session,\n save_path=base_save_path,\n global_step=self.global_step,\n latest_filename=self.params.cp_latest_filename)\n self.logger.log_info(\"Full model saved in file %s\"%full_save_path)\n return base_save_path","def save_session(self):\n\n # Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it\n checkpoint_dir = os.path.abspath(os.path.join(self.FLAGS.model_dir, \"checkpoints\"))\n checkpoint_prefix = os.path.join(checkpoint_dir, \"model\")\n if not os.path.exists(checkpoint_dir):\n os.makedirs(checkpoint_dir)\n current_step = tf.train.global_step(self.session, self.global_step)\n path = self.saver.save(self.session, checkpoint_prefix, global_step=current_step)\n print(\"Saved model checkpoint to {}\\n\".format(path))","def save(self, model, ema_model, optimizer, epoch, step, best_wer,\n is_best=False):\n rank = 0\n if dist.is_initialized():\n dist.barrier()\n rank = dist.get_rank()\n\n if rank != 0:\n return\n\n # Checkpoint already saved\n if not is_best and epoch in self.tracked:\n return\n\n unwrap_ddp = lambda model: getattr(model, 'module', model)\n state = {\n 'epoch': epoch,\n 'step': step,\n 'best_wer': best_wer,\n 'state_dict': unwrap_ddp(model).state_dict(),\n 'ema_state_dict': unwrap_ddp(ema_model).state_dict() if ema_model is not None else None,\n 'optimizer': optimizer.state_dict(),\n 'amp': amp.state_dict() if self.use_amp else None,\n }\n\n if is_best:\n fpath = os.path.join(\n self.save_dir, f\"{self.model_name}_best_checkpoint.pt\")\n else:\n fpath = os.path.join(\n self.save_dir, f\"{self.model_name}_epoch{epoch}_checkpoint.pt\")\n\n print_once(f\"Saving {fpath}...\")\n torch.save(state, fpath)\n\n if not is_best:\n # Remove old checkpoints; keep milestones and the last two\n self.tracked[epoch] = fpath\n for epoch in set(list(self.tracked)[:-2]) - set(self.keep_milestones):\n try:\n os.remove(self.tracked[epoch])\n except:\n pass\n del self.tracked[epoch]","def save(self, epoch: int, path: str = 'model.pt'):\n state_dict = {\n 'model_state_dict': self.state_dict(),\n 'epoch': epoch,\n 'ac_optim_dict': self.actor_optimizer.state_dict(),\n 'critic_optim_dict': self.critic_optimizer.state_dict()\n }\n\n torch.save(state_dict, path)","def save_checkpoint(state, filename):\n torch.save(state, filename) # save checkpoint","def save_checkpoint(state, filename='checkpoint.pth.tar'):\n torch.save(state, filename)","def save_model(args,model,epoch):\n path='./model_'+args.name\n if not os.path.exists(path):\n os.mkdir(path)\n model_name='checkpoint_epoch={}'.format(epoch)\n filepath=os.path.join(path,model_name)\n torch.save(model.state_dict(), filepath)","def checkpoint(iteration, G, D, opts):\n ckpt_path = os.path.join(opts.checkpoint_dir, 'ckpt_{:06d}.pth.tar'.format(iteration))\n torch.save({'G': G.state_dict(),\n 'D': D.state_dict(),\n 'iter': iteration}, \n ckpt_path)","def save_model(self, path, name, epoch=\"best\"):\n\n # Checks if the save directory exists and if not creates it.\n os.makedirs(path, exist_ok=True)\n\n # Saves the model to the save directory.\n torch.save(self.state_dict(), os.path.join(path, f\"{name}_sn_{str(epoch)}.pt\"))","def _save_params(self, output_folder: str, checkpoint: int):\n arg_params, aux_params = self.module.get_params() # sync aux params across devices\n self.module.set_params(arg_params, aux_params)\n self.params = arg_params\n params_base_fname = C.PARAMS_NAME % checkpoint\n self.save_params_to_file(os.path.join(output_folder, params_base_fname))","def save_checkpoint(self, model):\n # print(f\"save model {self.save_model_path}\")\n torch.save(model.state_dict(), self.save_model_path)","def save(self, directory: Optional[str] = None, epoch: Optional[int] = None, filename: Optional[str] = None):\n if directory is None and self.save_dir:\n directory = self.save_dir\n\n if directory is None:\n if filename is None:\n raise ValueError(\"The argument `directory` or `filename` must be specified.\")\n else:\n path = filename\n else:\n directory_path = Path(directory)\n if not directory_path.exists():\n directory_path.mkdir(parents=True)\n\n if epoch is None:\n epoch_str = ctime().replace(\" \", \"_\")\n else:\n epoch_str = str(epoch)\n\n if not filename:\n filename = \"enchanter_checkpoints_epoch_{}.pth\".format(epoch_str)\n\n path = str(directory_path / filename)\n\n checkpoint = self.save_checkpoint()\n torch.save(checkpoint, path)\n\n model_name = self.model_name()\n self.experiment.log_model(model_name, str(path))","def save_checkpoint(model, is_best, filename='./model/checkpoint.pth.tar'):\n if is_best:\n torch.save(model.state_dict(), filename) # save checkpoint\n else:\n print (\"=> Validation Accuracy did not improve\")","def save_model(net, epoch, opt):\r\n if opt.multi_gpu == True:\r\n if epoch % opt.save_by_epoch == 0:\r\n torch.save(net.module, './model/epoch%d_batchsize%d.pth' % (epoch, opt.batch_size))\r\n print('The trained model is successfully saved at epoch %d' % (epoch))\r\n else:\r\n if epoch % opt.save_by_epoch == 0:\r\n torch.save(net, './model/epoch%d_batchsize%d.pth' % (epoch, opt.batch_size))\r\n print('The trained model is successfully saved at epoch %d' % (epoch))","def save(self, folder):\n self.generator.save_weights('%s/generator.h5'%folder)\n self.critic.save_weights('%s/critic.h5'%folder)"],"string":"[\n \"def _save_checkpoint(checkpoint, model_dir, checkpoint_prefix):\\n\\n checkpoint_path = os.path.join(model_dir, checkpoint_prefix)\\n saved_path = checkpoint.save(checkpoint_path)\\n logging.info('Saving model as TF checkpoint: %s', saved_path)\\n return\",\n \"def save_checkpoint(checkpoint_dir, epoch, iteration, save_dict):\\n os.makedirs(checkpoint_dir, exist_ok=True)\\n path = opj(checkpoint_dir, str(epoch) + '.' + str(iteration) + '.ckpt')\\n assert epoch == save_dict['epoch'], \\\"`epoch` != save_dict's `start_epoch`\\\"\\n assert iteration == save_dict['iteration'], \\\"`iteration` != save_dict's `start_iteration`\\\"\\n if os.path.isfile(path):\\n print(\\\"Overwrite checkpoint in epoch %d, iteration %d :exclamation:\\\" % (epoch, iteration))\\n try:\\n torch.save(save_dict, path)\\n except Exception:\\n raise Exception(\\\"Fail to save checkpoint\\\")\\n \\n print(\\\"Checkpoint %s saved :heavy_check_mark:\\\" % (str(epoch) + '.' + str(iteration) + '.ckpt'))\",\n \"def save_checkpoint(ckpt_dir, model, optim, scheduler, epoch, global_step):\\n states = {\\n 'model': model.state_dict(),\\n 'optim': optim.state_dict(),\\n 'epoch': epoch,\\n 'global_step': global_step\\n }\\n if scheduler is not None:\\n states['scheduler'] = scheduler.state_dict()\\n ckpt_path = os.path.join(ckpt_dir, '[ep-{:02d}]giter-{}.ckpt'.format(epoch, global_step))\\n torch.save(states, ckpt_path)\\n\\n return ckpt_path\",\n \"def save(self, checkpoint_dir, step):\\n model_name = \\\"CNN.model\\\"\\n model_dir = \\\"%s\\\" % (\\\"cnn\\\")\\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir)\\n \\n if not os.path.exists(checkpoint_dir):\\n os.makedirs(checkpoint_dir)\\n \\n self.saver.save(self.sess,\\n os.path.join(checkpoint_dir, model_name),\\n global_step=step)\",\n \"def save_checkpoint(self, checkpoint_dir):\\r\\n\\r\\n if not os.path.exists(checkpoint_dir):\\r\\n os.makedirs(checkpoint_dir)\\r\\n\\r\\n path = os.path.join(checkpoint_dir, 'model.pt')\\r\\n torch.save(self.model.state_dict(), path)\",\n \"def save_model_checkpoint(model, optimizer, global_step, epoch_info, file_name):\\n output = {\\n \\\"model\\\" : model.state_dict(),\\n \\\"optimizer\\\" : optimizer.state_dict(),\\n \\\"global_step\\\" : global_step + 1,\\n \\\"epoch_info\\\" : epoch_info\\n }\\n torch.save(output, file_name)\",\n \"def save_checkpoint(args,state, is_best, filename=\\\"checkpoint.pth.tar\\\"):\\n directory = \\\"runs/%s-net/\\\" % (args.name)\\n\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n\\n epoch = state['epoch']\\n\\n filename = directory + filename\\n torch.save(state, filename)\\n\\n if is_best:\\n shutil.copyfile(filename, \\\"runs/%s-net/\\\" % (args.name) + \\\"model_best.pth.tar\\\")\\n\\n if epoch==0 or epoch==2:\\n shutil.copyfile(filename, \\\"runs/%s-net/\\\" % (args.name) + \\\"model_epoch_%d.pth.tar\\\" % epoch )\",\n \"def save_model(self, checkpoint_path, epoch):\\n self.saver.save(self.sess, checkpoint_path, global_step = epoch)\",\n \"def save_checkpoint(state, is_best, epoch, args, filename='checkpoint.pth'):\\n if not os.path.exists(args.save_folder):\\n os.makedirs(args.save_folder)\\n filename = args.save_folder + str(epoch) + '_' + filename\\n torch.save(state, filename)\\n if is_best:\\n shutil.copyfile(filename, args.save_folder + 'model_best.pth')\",\n \"def save_checkpoint(model, epoch, checkpoint_dir, stats):\\n state = {\\n \\\"epoch\\\": epoch,\\n \\\"state_dict\\\": model.state_dict(),\\n \\\"stats\\\": stats,\\n }\\n\\n filename = os.path.join(checkpoint_dir, \\\"epoch={}.checkpoint.pth.tar\\\".format(epoch))\\n torch.save(state, filename)\",\n \"def save(self, epoch=None, note=None):\\n\\n checkpoint_encoder = {\\n 'type': \\\"transformer\\\",\\n 'model': self.model.encoder.state_dict(),\\n 'epoch': epoch,\\n 'settings': self.opt\\n }\\n\\n if checkpoint_encoder['settings'].telegram:\\n del checkpoint_encoder['settings'].telegram\\n\\n checkpoint_decoder = {\\n 'type': \\\"transformer\\\",\\n 'model': self.model.decoder.state_dict(),\\n 'generator': self.model.generator.state_dict(),\\n 'epoch': epoch,\\n 'settings': self.opt\\n }\\n\\n if checkpoint_decoder['settings'].telegram:\\n del checkpoint_decoder['settings'].telegram\\n\\n if not note:\\n note = \\\"\\\"\\n\\n # make sure a path is specified prior to saving the files.\\n if self.opt.save_model:\\n ready_to_save = False\\n if self.opt.save_mode == \\\"all\\\":\\n model_name = \\\"_\\\" + str(note)\\n ready_to_save = True\\n else:\\n # assumes self.opt.save_mode = \\\"best\\\"\\n if self.valid_accs[-1] >= max(self.valid_accs):\\n model_name = \\\"\\\"\\n ready_to_save = True\\n if self.opt.verbose:\\n print(\\n ' - [Info] The checkpoint file has been updated.')\\n if ready_to_save:\\n encoder_name = \\\"encoder\\\" + model_name + \\\".chkpt\\\"\\n decoder_name = \\\"decoder\\\" + model_name + \\\".chkpt\\\"\\n # setup directory to save this at.\\n encoder_filepath = os.path.join(\\n self.opt.directory, encoder_name)\\n decoder_filepath = os.path.join(\\n self.opt.directory, decoder_name)\\n torch.save(checkpoint_encoder, encoder_filepath)\\n torch.save(checkpoint_decoder, decoder_filepath)\\n else:\\n if not self.save_trip:\\n if self.opt.verbose:\\n print(\\n \\\" - [Warning]: the model is not specified to save.\\\")\\n self.save_trip = True\",\n \"def checkpoint_save(self, epoch, model, label=None, checkpoint=None, path=\\\"\\\"):\\n\\n if label is None:\\n label = f\\\"checkpoint-{epoch}\\\"\\n else:\\n label = f\\\"{label}-checkpoint-{epoch}\\\"\\n\\n if checkpoint is None:\\n pass\\n elif checkpoint == -1:\\n Potentials.save(model=model, label=label, path=path)\\n elif epoch % checkpoint == 0:\\n Potentials.save(model=model, label=label, path=path)\",\n \"def save_checkpoint(self):\\n \\n if not os.path.isdir(self.path + '/checkpoint/'):\\n os.makedirs(self.path + '/checkpoint/')\\n\\n if self.saver == None:\\n with self.graph.as_default():\\n self.saver = tf.train.Saver(tf.global_variables())\\n\\n self.saver.save(self.session, self.path + '/checkpoint/model.ckpt')\",\n \"def save_checkpoint(self, model_path=None):\\n # TODO: include new params based on ConfigEnum\\n if not os.path.isdir(path_checkpoints_dir):\\n os.mkdir(path_checkpoints_dir)\\n if model_path is None:\\n model_path = os.path.join(path_checkpoints_dir, f\\\"{self.experiment_id}.pth\\\")\\n print(f\\\"saved the model at {model_path}\\\") \\n model_state_dict = self.model.state_dict()\\n if self.optimizer is not None:\\n opt_state_dict = self.optimizer.state_dict()\\n else:\\n opt_state_dict = None\\n if self.scheduler is not None:\\n sch_state_dict = self.scheduler.state_dict()\\n else:\\n sch_state_dict = None\\n \\n if self.scaler is not None:\\n amp_grad_scaler = self.scaler.state_dict()\\n else:\\n amp_grad_scaler = None\\n\\n model_dict = {}\\n model_dict[\\\"state_dict\\\"] = model_state_dict\\n model_dict[\\\"optimizer\\\"] = opt_state_dict\\n model_dict[\\\"scheduler\\\"] = sch_state_dict\\n model_dict['scaler'] = amp_grad_scaler\\n model_dict['image_size'] = self.image_size\\n model_dict['device'] = self.device\\n model_dict['fp16'] = self.fp16\\n model_dict['accumulate_grad_steps'] = self.accumulate_grad_steps\\n\\n model_dict['experiment_id'] = self.experiment_id\\n model_dict['experiment_tag'] = self.experiment_tag\\n\\n model_dict['seed'] = self.seed\\n\\n model_dict['train_batch_size'] = self.train_batch_size\\n model_dict['valid_batch_size'] = self.valid_batch_size\\n model_dict['test_batch_size'] = self.test_batch_size\\n model_dict['dataloader_num_workers'] = self.dataloader_num_workers\\n model_dict['train_dataloader_shuffle'] = self.train_dataloader_shuffle\\n\\n model_dict['optimizer_type'] = self.optimizer_type\\n model_dict['optimizer_params'] = self.optimizer_params\\n\\n model_dict['scheduler_type'] = self.scheduler_type\\n model_dict['scheduler_params'] = self.scheduler_params\\n model_dict['step_scheduler_after'] = self.step_scheduler_after\\n model_dict['step_scheduler_metric'] = self.step_scheduler_metric\\n\\n model_dict['compute_train_loss_after'] = self.compute_train_loss_after\\n model_dict['compute_train_metric_after'] = self.compute_train_metric_after\\n model_dict['compute_valid_loss_after'] = self.compute_valid_loss_after\\n model_dict['compute_valid_metric_after'] = self.compute_valid_metric_after\\n\\n model_dict['training_stopping_criteria'] = self.training_stopping_criteria\\n model_dict['stopping_criteria_params'] = self.stopping_criteria_params\\n model_dict['max_epoch'] = self.max_epoch\\n model_dict['train_on_all_data'] = self.train_on_all_data\\n model_dict['validate_after'] = self.validate_after\\n model_dict['validation_steps'] = self.validation_steps\\n model_dict['run_lr_range_test'] = self.run_lr_range_test\\n model_dict['sleep_in_epochs'] = self.sleep_in_epochs\\n model_dict['sleep_time'] = self.sleep_time\\n model_dict['checkpoint_epochs'] = self.checkpoint_epochs\\n\\n model_dict['_best_score'] = self._best_score\\n model_dict['_current_score'] = self._current_score\\n model_dict['_counter'] = self._counter\\n\\n model_dict['metrics'] = self.metrics\\n model_dict['current_epoch'] = self.current_epoch\\n model_dict['current_train_batch'] = self.current_train_batch\\n model_dict['current_valid_batch'] = self.current_valid_batch\\n\\n model_dict['num_train_samples'] = self.num_train_samples\\n model_dict['num_train_iterations'] = self.num_train_iterations\\n model_dict['checkpoint_snapshot'] = self.checkpoint_snapshot \\n torch.save(model_dict, model_path)\",\n \"def save_checkpoint(tag, params, model):\\r\\n os.makedirs(os.path.join(\\\"saved_models\\\", params.path), exist_ok=True)\\r\\n state = {\\r\\n 'training_id': params.training_id,\\r\\n 'global_step': model.global_step,\\r\\n 'model': model.state_dict(),\\r\\n 'optimizers': [optimizer.state_dict() for optimizer in model.optimizers]\\r\\n }\\r\\n fn = os.path.join(\\\"saved_models\\\", params.path, tag + \\\".pt\\\")\\r\\n torch.save(state, fn)\",\n \"def save_checkpoint(self, model, optimizers):\\n\\n def _save(path, model, optimizers):\\n if not os.path.exists(path):\\n os.makedirs(path)\\n # TODO: put everything on CPU first\\n torch.save(model.state_dict(), os.path.join(path, 'model.ckpt'))\\n torch.save(tuple([optimizer.opt.state_dict() for optimizer in optimizers]),\\n os.path.join(path, 'opt.ckpt'))\\n\\n if (self.epoch % self._save_iter) == 0:\\n # we're at a save iteration\\n ckpt_path = os.path.join(self.log_path, 'checkpoints', str(self.epoch))\\n _save(ckpt_path, model, optimizers)\\n\\n if self._best_epoch:\\n # overwrite the best model\\n ckpt_path = os.path.join(self.log_path, 'checkpoints', 'best')\\n _save(ckpt_path, model, optimizers)\\n self._best_epoch = False\",\n \"def save_checkpoint(model, path):\\n\\n model_name = path.split('-')[0]\\n assert (model_name in ['vgg16', 'resnet50'\\n ]), \\\"Path must have the correct model name\\\"\\n\\n # Basic details\\n checkpoint = {\\n 'class_to_idx': model.class_to_idx,\\n 'idx_to_class': model.idx_to_class,\\n 'epochs': model.epochs,\\n }\\n\\n # Extract the final classifier and the state dictionary\\n if model_name == 'vgg16':\\n # Check to see if model was parallelized\\n if multi_gpu:\\n checkpoint['classifier'] = model.module.classifier\\n checkpoint['state_dict'] = model.module.state_dict()\\n else:\\n checkpoint['classifier'] = model.classifier\\n checkpoint['state_dict'] = model.state_dict()\\n\\n elif model_name == 'resnet50':\\n if multi_gpu:\\n checkpoint['fc'] = model.module.fc\\n checkpoint['state_dict'] = model.module.state_dict()\\n else:\\n checkpoint['fc'] = model.fc\\n checkpoint['state_dict'] = model.state_dict()\\n\\n # Add the optimizer\\n checkpoint['optimizer'] = model.optimizer\\n checkpoint['optimizer_state_dict'] = model.optimizer.state_dict()\\n\\n # Save the data to the path\\n torch.save(checkpoint, path)\",\n \"def save_model_checkpoint(base_name, model, ep, opt):\\n # Save only the model params\\n model_name = os.path.join(base_name, \\\"i3d_ep\\\"+str(ep)+\\\"_\\\"+opt+\\\".pt\\\")\\n\\n torch.save(model.state_dict(), model_name)\\n print(\\\"Model saved to disk... : {}\\\".format(model_name))\",\n \"def save(self, experiment_dir):\\n date_time = time.strftime('%Y_%m_%d_%H_%M_%S', time.localtime())\\n\\n if self.eval_results is not None:\\n # print(self.eval_results)\\n assert isinstance(self.eval_results, dict)\\n # present the dict in str form\\n # res_str = ''.join(''.join(str(x) for x in tup) for tup in self.eval_results.items())\\n\\n self._path = os.path.join(\\n experiment_dir, self.CHECKPOINT_DIR_NAME, date_time,\\n )\\n path = self._path\\n\\n if os.path.exists(path):\\n shutil.rmtree(path)\\n os.makedirs(path)\\n\\n torch.save(\\n {'epoch': self.epoch, 'optimizer': self.optimizer},\\n os.path.join(path, self.TRAINER_STATE_NAME)\\n )\\n torch.save(self.model, os.path.join(path, self.MODEL_NAME))\\n\\n # save parameters to txt\\n txt_file = open(os.path.join(path, self.PARAMETERS), \\\"w\\\")\\n\\n txt_file.write(f\\\"ckpt name: '{date_time}'\\\\n\\\")\\n txt_file.write(f\\\"epoch: {self.epoch}\\\\n\\\")\\n\\n if self.eval_results is not None: \\n for key, value in self.eval_results.items():\\n txt_file.write(str(key)+': '+str(value)+'\\\\n')\\n # if 'acc' in self.eval_results:\\n # txt_file.write(f\\\"acc: {self.eval_results['acc']}\\\\n\\\")\\n # if 'p' in self.eval_results:\\n # txt_file.write(f\\\"p: {self.eval_results['p']}\\\\n\\\")\\n # if 'r' in self.eval_results:\\n # txt_file.write(f\\\"r: {self.eval_results['r']}\\\\n\\\")\\n # if 'f1' in self.eval_results:\\n # txt_file.write(f\\\"f1: {self.eval_results['f1']}\\\\n\\\")\\n \\n txt_file.close()\\n\\n return path\",\n \"def save_checkpoint(self, label):\\n model_dir = os.path.join(\\n config.results_dir, config.experiment_name, 'checkpoints')\\n os.makedirs(model_dir, exist_ok=True)\\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\\n\\n model_dict = {'net_state_dict': self.net.state_dict(),\\n 'use_cuda': self.use_cuda}\\n\\n print(\\\"Saving model to {}\\\".format(model_file))\\n torch.save(model_dict, model_file)\",\n \"def save_checkpoint(self, name=''):\\n self.checkpoint_path.mkdir(exist_ok=True)\\n if name:\\n path = self.checkpoint_path / f'{name}_{self.epoch}.tar'\\n else:\\n path = self.checkpoint_path / f'{self.epoch}.tar'\\n torch.save(self.get_state(), path)\",\n \"def save(self, checkpoint_dir, step):\\n\\n model_name = \\\"CSGAN.model\\\"\\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\\n\\n if not os.path.exists(checkpoint_dir):\\n os.makedirs(checkpoint_dir)\\n\\n self.saver.save(self.sess, os.path.join(checkpoint_dir, model_name), global_step=step)\",\n \"def save_checkpoint(self, folder='checkpoint', filename='checkpoint.pth.tar'):\\n data = dict()\\n data[\\\"inst\\\"] = \\\"save\\\"\\n data[\\\"folder\\\"] = folder\\n data[\\\"filename\\\"] = filename\\n\\n q_idx, data_id = self.put(data, q_idx=0) # Send instruction to first nnet\\n self.get(q_idx, data_id) # Blocks here\\n\\n # Done\",\n \"def save_checkpoint(model, state, is_best, checkpoint):\\n state_filepath = os.path.join(checkpoint, 'last.pth.tar')\\n model_filepath = os.path.join(checkpoint, 'last_model.pth')\\n if not os.path.exists(checkpoint):\\n print(\\\"Checkpoint Directory does not exist! Making directory {}\\\".format(checkpoint))\\n os.mkdir(checkpoint)\\n else:\\n print(\\\"Checkpoint Directory exists! \\\")\\n torch.save(state, state_filepath)\\n torch.save(model, model_filepath)\\n if is_best:\\n shutil.copyfile(state_filepath, os.path.join(checkpoint, 'best.pth.tar'))\\n shutil.copyfile(model_filepath, os.path.join(checkpoint, 'best_model.pth'))\",\n \"def saveCheckpoint(acc, epoch, model, train_hist):\\r\\n print('Saving..')\\r\\n state = {\\r\\n 'model': model,\\r\\n 'acc': acc,\\r\\n 'epoch': epoch,\\r\\n 'rng_state': torch.get_rng_state(),\\r\\n 'train_hist': train_hist\\r\\n }\\r\\n if not os.path.isdir('checkpoint'): # save to checkpoint directory\\r\\n os.mkdir('checkpoint')\\r\\n torch.save(state, './checkpoint/ckpt' + '_' + str(epoch+1))\",\n \"def save_checkpoint(dir, state, is_best, filename='checkpoint.pth.tar'):\\n directory = \\\"%s/\\\" % (dir)\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n filename = directory + filename\\n torch.save(state, filename)\\n if is_best:\\n shutil.copyfile(filename, '%s/' %\\n (dir) + 'model_best.pth.tar')\",\n \"def save_checkpoint(state: dict, is_best: bool, filename: str = 'checkpoint.pth.tar', args: Namespace = None):\\n directory = f\\\"runs/{args.name}/\\\"\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n filename = directory + filename\\n torch.save(state, filename)\\n if is_best:\\n shutil.copyfile(filename, f'runs/{args.name}/model_best.pth.tar')\",\n \"def save(self, checkpoint) -> None:\\r\\n self.model.save(checkpoint)\",\n \"def _save_model(self, checkpoint_dir):\\n # Check whether the specified path exists or not\\n isExist = os.path.exists(checkpoint_dir)\\n\\n if not isExist:\\n # Create a new directory because it does not exist\\n os.makedirs(checkpoint_dir)\\n\\n filename = self._get_checkpoint_name()\\n path = checkpoint_dir + filename\\n\\n # Serialize the model checkpoint in to a Python Pickle file\\n with open(path, 'wb') as f:\\n pickle.dump(self._model, f)\\n return path\",\n \"def _save(self, tmp_checkpoint_dir):\\n checkpoint_path = os.path.join(tmp_checkpoint_dir, \\\"model_weights\\\")\\n self.model.save_weights(checkpoint_path, save_format=\\\"tf\\\")\\n return tmp_checkpoint_dir\",\n \"def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):\\n directory = \\\"runs/%s/\\\"%(args.name)\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n filename = directory + filename\\n torch.save(state, filename)\\n if is_best:\\n shutil.copyfile(filename, 'runs/%s/'%(args.name) + 'model_best.pth.tar')\",\n \"def create_checkpoint(model, save_dir, train_data):\\n model.class_to_idx = train_data.class_to_idx\\n\\n checkpoint = {\\n 'model': model.name,\\n 'classifier': model.classifier,\\n 'class_to_idx': model.class_to_idx,\\n 'state_dict': model.state_dict()\\n }\\n\\n if save_dir and isdir(save_dir):\\n torch.save(checkpoint, save_dir + 'checkpoint.pth')\\n print('checkpoint created')\\n else: \\n print(\\\"Directory not found. Saving at current directory in checkpoint.pth\\\")\\n torch.save(checkpoint, 'checkpoint.pth')\",\n \"def save_checkpoint(epoch, outdir, model, mapper, optimizer, criterion,\\n filename='checkpoint.OWE.pth.tar'):\\n filename = outdir / filename\\n logger.info(\\\"Saving checkpoint to {}.\\\".format(filename))\\n torch.save({'epoch': epoch,\\n 'model': model.state_dict(),\\n 'mapper': mapper.state_dict(),\\n 'optimizer': optimizer.state_dict(),\\n }, str(filename))\\n if max(criterion) == criterion[-1]:\\n best_name = str(outdir / 'best_checkpoint.OWE.pth.tar')\\n shutil.copyfile(str(filename), best_name)\\n logger.info(\\\"Saved best checkpoint to {}.\\\".format(best_name))\",\n \"def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):\\n directory = \\\"runs/%s/\\\" % (args.name)\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n filename = directory + filename\\n torch.save(state, filename)\\n if is_best:\\n shutil.copyfile(filename, 'runs/%s/' % (args.name) + 'model_best.pth.tar')\",\n \"def save_checkpoint(checkpoint_dir, model_encoder_noisy_clean, model_encoder_noisy_noise, model_decoder_noisy,\\n model_encoder_clean, model_decoder_clean, model_encoder_noise, model_decoder_noise,\\n model_classifier, min_eval_loss_melsp_y_dB, min_eval_loss_melsp_y_dB_std,\\n iter_idx, min_idx, optimizer, numpy_random_state, torch_random_state, iterations, model_spkidtr=None):\\n model_encoder_noisy_clean.cpu()\\n model_encoder_noisy_noise.cpu()\\n model_decoder_noisy.cpu()\\n model_encoder_clean.cpu()\\n model_decoder_clean.cpu()\\n model_encoder_noise.cpu()\\n model_decoder_noise.cpu()\\n model_classifier.cpu()\\n checkpoint = {\\n \\\"model_encoder_noisy_clean\\\": model_encoder_noisy_clean.state_dict(),\\n \\\"model_encoder_noisy_noise\\\": model_encoder_noisy_noise.state_dict(),\\n \\\"model_decoder_noisy\\\": model_decoder_noisy.state_dict(),\\n \\\"model_encoder_clean\\\": model_encoder_clean.state_dict(),\\n \\\"model_decoder_clean\\\": model_decoder_clean.state_dict(),\\n \\\"model_encoder_noise\\\": model_encoder_noise.state_dict(),\\n \\\"model_decoder_noise\\\": model_decoder_noise.state_dict(),\\n \\\"model_classifier\\\": model_classifier.state_dict(),\\n \\\"min_eval_loss_melsp_y_dB\\\": min_eval_loss_melsp_y_dB,\\n \\\"min_eval_loss_melsp_y_dB_std\\\": min_eval_loss_melsp_y_dB_std,\\n \\\"iter_idx\\\": iter_idx,\\n \\\"min_idx\\\": min_idx,\\n \\\"optimizer\\\": optimizer.state_dict(),\\n \\\"numpy_random_state\\\": numpy_random_state,\\n \\\"torch_random_state\\\": torch_random_state,\\n \\\"iterations\\\": iterations}\\n if not os.path.exists(checkpoint_dir):\\n os.makedirs(checkpoint_dir)\\n torch.save(checkpoint, checkpoint_dir + \\\"/checkpoint-%d.pkl\\\" % iterations)\\n model_encoder_noisy_clean.cuda()\\n model_encoder_noisy_noise.cuda()\\n model_decoder_noisy.cuda()\\n model_encoder_clean.cuda()\\n model_decoder_clean.cuda()\\n model_encoder_noise.cuda()\\n model_decoder_noise.cuda()\\n model_classifier.cuda()\\n logging.info(\\\"%d-iter checkpoint created.\\\" % iterations)\",\n \"def save(self, checkpoint_path: str):\\r\\n raise NotImplementedError\",\n \"def _save(trainer, checkpoint_dir, state_dict_key_name, world_rank=None):\\n\\n # save current model parameters as a checkpoint\\n makedir(checkpoint_dir)\\n checkpoint_file_name = 'checkpoint{}.ortcp'.format('' if world_rank is None else str(world_rank))\\n trainer.save_checkpoint(os.path.join(checkpoint_dir, checkpoint_file_name))\\n state_dict = trainer.state_dict()\\n with open(os.path.join(checkpoint_dir, state_dict_key_name+'.pkl'), \\\"wb\\\") as f:\\n pickle.dump({state_dict_key_name : state_dict}, f)\",\n \"def save_checkpoint(self, checkpoint_path='checkpoint.pth'):\\n # Move the model back to the cpu so it can be loaded onto machines\\n # without gpu's as well.\\n self.model.to('cpu')\\n\\n checkpoint = {\\n 'model_architecture': self.model_architecture,\\n 'input_size': self.input_size,\\n 'output_size': self.output_size,\\n 'hidden_layers': self.hidden_layers,\\n 'learn_rate': self.learn_rate,\\n 'drop_p': self.drop_p,\\n 'class_to_idx': self.model.class_to_idx,\\n 'current_epoch': self.model.current_epoch,\\n 'optimizer_state_dict': self.optimizer.state_dict(),\\n 'model_state_dict': self.model.state_dict()\\n }\\n torch.save(checkpoint, checkpoint_path)\",\n \"def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):\\n directory = \\\"checkoutpoint/%s/\\\" % args.name\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n filename = directory + filename\\n torch.save(state, filename)\\n if is_best:\\n shutil.copyfile(filename, 'checkoutpoint/%s/' % args.name + 'model_best.pth.tar')\",\n \"def _save_model(self, epoch, batch, logs):\\n self.save(self._get_file_path(epoch, batch, logs))\",\n \"def save_checkpoint(state, is_best, checkpoint_dir, logger=None):\\n\\n def log_info(message):\\n if logger is not None:\\n logger.info(message)\\n\\n if not os.path.exists(checkpoint_dir):\\n log_info(\\n f\\\"Checkpoint directory does not exists. Creating {checkpoint_dir}\\\")\\n os.mkdir(checkpoint_dir)\\n\\n last_file_path = os.path.join(checkpoint_dir, f'epoch{state[\\\"epoch\\\"]}_checkpoint.pytorch')\\n log_info(f\\\"Saving last checkpoint to '{last_file_path}'\\\")\\n torch.save(state, last_file_path)\\n if is_best:\\n best_file_path = os.path.join(checkpoint_dir, 'best_checkpoint.pytorch')\\n log_info(f\\\"Saving best checkpoint to '{best_file_path}'\\\")\\n shutil.copyfile(last_file_path, best_file_path)\",\n \"def save(self):\\n\\n self.saver.save(self.sess, self.path + '/tensorflow-model', global_step=self.counter.count)\",\n \"def save_checkpoint(filename, epoch, model, optimizer=None, best_score=0):\\n torch.save({\\n 'model' : model.state_dict(),\\n 'optim' : optimizer.state_dict() if optimizer is not None else None,\\n 'epoch' : epoch,\\n 'best_score' : best_score\\n }, filename)\",\n \"def save_checkpoint(model, save_path):\\n torch.save(model.state_dict(), save_path)\",\n \"def save(self, model_dir, step, epoch, is_best=False):\\n if model_dir is None:\\n return\\n save_checkpoint(self._model, self._optimizer, step, epoch, model_dir,\\n keep_every_n=self._keep_every_n, is_best=is_best)\",\n \"def checkpoint(self, epoch, losses, path):\\n dct = {'epoch': epoch, \\n 'losses': losses, \\n 'model_state_dict': self.TrajectoryAutoencoder.state_dict()}\\n torch.save(dct, path)\",\n \"def save_checkpoint(self, checkpoint_info):\\n torch.save(checkpoint_info, os.path.join(self.checkpoint_path, self.checkpoint_file))\",\n \"def save_model(self, epoch):\\n ckpt_path = os.path.join(self.config.save_path, f'{epoch}.pkl')\\n print(f'Save parameters to {ckpt_path}')\\n torch.save(self.model.state_dict(), ckpt_path)\",\n \"def save_checkpoint(self):\\n checkpoin_path = self.get_checkpoint_path()\\n _logger.info('Save checkpoint ignored by tuner, checkpoint path: %s', checkpoin_path)\",\n \"def create_checkpoint(model_config, path):\\n model = models.VisionTransformer(num_classes=1, **model_config)\\n variables = model.init(\\n jax.random.PRNGKey(0),\\n jnp.ones([1, 16, 16, 3], jnp.float32),\\n train=False,\\n )\\n _save(variables['params'], path)\",\n \"def save_checkpoint(self, checkpoint_dir: str) -> None:\\n state = self.__getstate__()\\n\\n # Extract policy states from worker state (Policies get their own\\n # checkpoint sub-dirs).\\n policy_states = {}\\n if \\\"worker\\\" in state and \\\"policy_states\\\" in state[\\\"worker\\\"]:\\n policy_states = state[\\\"worker\\\"].pop(\\\"policy_states\\\", {})\\n\\n # Add RLlib checkpoint version.\\n if self.config._enable_learner_api:\\n state[\\\"checkpoint_version\\\"] = CHECKPOINT_VERSION_LEARNER\\n else:\\n state[\\\"checkpoint_version\\\"] = CHECKPOINT_VERSION\\n\\n # Write state (w/o policies) to disk.\\n state_file = os.path.join(checkpoint_dir, \\\"algorithm_state.pkl\\\")\\n with open(state_file, \\\"wb\\\") as f:\\n pickle.dump(state, f)\\n\\n # Write rllib_checkpoint.json.\\n with open(os.path.join(checkpoint_dir, \\\"rllib_checkpoint.json\\\"), \\\"w\\\") as f:\\n json.dump(\\n {\\n \\\"type\\\": \\\"Algorithm\\\",\\n \\\"checkpoint_version\\\": str(state[\\\"checkpoint_version\\\"]),\\n \\\"format\\\": \\\"cloudpickle\\\",\\n \\\"state_file\\\": state_file,\\n \\\"policy_ids\\\": list(policy_states.keys()),\\n \\\"ray_version\\\": ray.__version__,\\n \\\"ray_commit\\\": ray.__commit__,\\n },\\n f,\\n )\\n\\n # Write individual policies to disk, each in their own sub-directory.\\n for pid, policy_state in policy_states.items():\\n # From here on, disallow policyIDs that would not work as directory names.\\n validate_policy_id(pid, error=True)\\n policy_dir = os.path.join(checkpoint_dir, \\\"policies\\\", pid)\\n os.makedirs(policy_dir, exist_ok=True)\\n policy = self.get_policy(pid)\\n policy.export_checkpoint(policy_dir, policy_state=policy_state)\\n\\n # if we are using the learner API, save the learner group state\\n if self.config._enable_learner_api:\\n learner_state_dir = os.path.join(checkpoint_dir, \\\"learner\\\")\\n self.learner_group.save_state(learner_state_dir)\",\n \"def _save_checkpoint(self, epoch, is_best=False):\\n arch = type(self.model).__name__\\n state = {\\n 'arch': arch,\\n 'epoch': epoch,\\n 'state_dict': self.model.state_dict(),\\n 'optimizer': self.optimizer.state_dict(),\\n 'config': self.config\\n }\\n filename = str(self.checkpoint_dir / 'checkpoint-epoch{}.pth'.format(epoch))\\n torch.save(state, filename)\\n self.logger.info(\\\"Saving checkpoint: {} ...\\\".format(filename))\\n if is_best:\\n best_path = str(self.checkpoint_dir / 'model_best.pth')\\n torch.save(state, best_path)\\n self.logger.info(\\\"Saving current best: model_best.pth ...\\\")\",\n \"def save_checkpoint(state, model_name=None):\\n \\n if not model_name: model_name = f\\\"model_date_{date_time_str}.pth\\\"\\n torch.save(state, osj(out_path, model_name))\",\n \"def save_checkpoint(state, is_best, checkpoint_dir, logger=None):\\n\\n def log_info(message):\\n if logger is not None:\\n logger.info(message)\\n\\n if not os.path.exists(checkpoint_dir):\\n log_info(\\n \\\"Checkpoint directory does not exists. Creatding {}\\\".format(checkpoint_dir))\\n os.mkdir(checkpoint_dir)\\n\\n last_file_path = os.path.join(checkpoint_dir, 'last_checkpoint.pytorch')\\n log_info(\\\"Saving last checkpoint\\\")\\n torch.save(state, last_file_path)\\n if is_best:\\n best_file_path = os.path.join(checkpoint_dir, 'best_checkpoint.pytorch')\\n log_info(\\\"Saving best checkpoint\\\")\\n shutil.copyfile(last_file_path, best_file_path)\",\n \"def save_model(self, dir=\\\"\\\", **kwargs):\\n ckpt_fn = os.path.join(dir, f\\\"model.pkl\\\")\\n torch.save(\\n {\\n \\\"global_step\\\": self.global_step_,\\n \\\"epoch\\\": self.epoch_,\\n \\\"model\\\": self.net_.state_dict(),\\n \\\"optimizer\\\": self.optimizer_.state_dict(),\\n \\\"sampler_state\\\": self.sampler.state_dict(),\\n \\\"model_samples\\\": list(self.model_samples_),\\n \\\"ais_state\\\": self.ais_loss.state_dict(),\\n \\\"replay_prob\\\": self.replay_prob,\\n \\\"max_replay\\\": self.max_replay,\\n },\\n ckpt_fn,\\n )\\n return ckpt_fn\",\n \"def save_checkpoint(model, filename, optimizer=None, meta=None):\\n if meta is None:\\n meta = {}\\n elif not isinstance(meta, dict):\\n raise TypeError(f'meta must be a dict or None, but got {type(meta)}')\\n meta.update(mmcv_version=mmcv.__version__, time=time.asctime())\\n\\n if is_module_wrapper(model):\\n model = model.module\\n\\n if hasattr(model, 'CLASSES') and model.CLASSES is not None:\\n # save class name to the meta\\n meta.update(CLASSES=model.CLASSES)\\n\\n checkpoint = {\\n 'meta': meta,\\n 'state_dict': weights_to_cpu(get_state_dict(model))\\n }\\n # save optimizer state dict in the checkpoint\\n if isinstance(optimizer, Optimizer):\\n checkpoint['optimizer'] = optimizer.state_dict()\\n elif isinstance(optimizer, dict):\\n checkpoint['optimizer'] = {}\\n for name, optim in optimizer.items():\\n checkpoint['optimizer'][name] = optim.state_dict()\\n\\n if filename.startswith('pavi://'):\\n try:\\n from pavi import modelcloud\\n from pavi.exception import NodeNotFoundError\\n except ImportError as e:\\n raise ImportError(\\n 'Please install pavi to load checkpoint from modelcloud.') from e\\n model_path = filename[7:]\\n root = modelcloud.Folder()\\n model_dir, model_name = osp.split(model_path)\\n try:\\n model = modelcloud.get(model_dir)\\n except NodeNotFoundError:\\n model = root.create_training_model(model_dir)\\n with TemporaryDirectory() as tmp_dir:\\n checkpoint_file = osp.join(tmp_dir, model_name)\\n with open(checkpoint_file, 'wb') as f:\\n torch.save(checkpoint, f)\\n f.flush()\\n model.create_file(checkpoint_file, name=model_name)\\n else:\\n mmcv.mkdir_or_exist(osp.dirname(filename))\\n # immediately flush buffer\\n with open(filename, 'wb') as f:\\n torch.save(checkpoint, f)\\n f.flush()\",\n \"def save(self):\\n\\n if self.ckpt_manager is not None:\\n save_path = self.ckpt_manager.save()\\n print(\\\"Saved checkpoint at: {}\\\".format(save_path))\\n else:\\n print(\\\"There is no checkpoint manager supplied for saving the \\\"\\n \\\"network weights, optimizer, or other trackables.\\\")\\n print(\\\"Therefore these will not be saved and the training will \\\"\\n \\\"start from default values in the future.\\\")\\n print(\\\"Consider using a checkpoint manager to save the network \\\"\\n \\\"weights and optimizer.\\\")\",\n \"def save_checkpoint(filename, model, state=None):\\n if not state:\\n torch.save(model.state_dict(), os.path.join('checkpoints/', filename))\\n else:\\n _state = {\\n 'epoch': state['epoch'],\\n 'state_dict': state['state_dict'].state_dict(),\\n 'optimizer': state['optimizer'].state_dict()\\n }\\n\\n torch.save(_state, os.path.join('checkpoints/', filename))\",\n \"def save_checkpoint(state, is_best, checkpoint_dir):\\n\\n if not os.path.exists(checkpoint_dir):\\n os.mkdir(checkpoint_dir)\\n\\n last_file_path = os.path.join(checkpoint_dir, 'last_checkpoint.pytorch')\\n torch.save(state, last_file_path)\\n if is_best:\\n best_file_path = os.path.join(checkpoint_dir, 'best_checkpoint.pytorch')\\n shutil.copyfile(last_file_path, best_file_path)\",\n \"def checkpoint_model(PATH, ckpt_id, model, epoch, last_global_step,\\r\\n last_global_data_samples, **kwargs):\\r\\n checkpoint_state_dict = {\\r\\n 'epoch': epoch,\\r\\n 'last_global_step': last_global_step,\\r\\n 'last_global_data_samples': last_global_data_samples\\r\\n }\\r\\n # Add extra kwargs too\\r\\n checkpoint_state_dict.update(kwargs)\\r\\n\\r\\n success = model.network.save_checkpoint(PATH, ckpt_id,\\r\\n checkpoint_state_dict)\\r\\n status_msg = 'checkpointing: PATH={}, ckpt_id={}'.format(PATH, ckpt_id)\\r\\n if success:\\r\\n logging.info(f\\\"Success {status_msg}\\\")\\r\\n else:\\r\\n logging.warning(f\\\"Failure {status_msg}\\\")\\r\\n return\",\n \"def save_checkpoint(checkpoint_dir, model_encoder_melsp, model_decoder_melsp, model_encoder_excit, model_decoder_excit,\\n model_classifier, model_post, min_eval_loss_melsp_dB, min_eval_loss_melsp_dB_std, min_eval_loss_melsp_cv,\\n min_eval_loss_melsp, min_eval_loss_melsp_dB_src_trg, min_eval_loss_melsp_dB_src_trg_std, min_eval_loss_laplace,\\n min_eval_loss_laplace_cv, iter_idx, min_idx, optimizer, numpy_random_state, torch_random_state,\\n iterations, model_spkidtr=None):\\n model_encoder_melsp.cpu()\\n model_decoder_melsp.cpu()\\n model_encoder_excit.cpu()\\n model_decoder_excit.cpu()\\n model_classifier.cpu()\\n model_post.cpu()\\n if model_spkidtr is not None:\\n model_spkidtr.cpu()\\n checkpoint = {\\n \\\"model_encoder_melsp\\\": model_encoder_melsp.state_dict(),\\n \\\"model_decoder_melsp\\\": model_decoder_melsp.state_dict(),\\n \\\"model_encoder_excit\\\": model_encoder_excit.state_dict(),\\n \\\"model_decoder_excit\\\": model_decoder_excit.state_dict(),\\n \\\"model_classifier\\\": model_classifier.state_dict(),\\n \\\"model_spkidtr\\\": model_spkidtr.state_dict(),\\n \\\"model_post\\\": model_post.state_dict(),\\n \\\"min_eval_loss_melsp_dB\\\": min_eval_loss_melsp_dB,\\n \\\"min_eval_loss_melsp_dB_std\\\": min_eval_loss_melsp_dB_std,\\n \\\"min_eval_loss_melsp_cv\\\": min_eval_loss_melsp_cv,\\n \\\"min_eval_loss_melsp\\\": min_eval_loss_melsp,\\n \\\"min_eval_loss_melsp_dB_src_trg\\\": min_eval_loss_melsp_dB_src_trg,\\n \\\"min_eval_loss_melsp_dB_src_trg_std\\\": min_eval_loss_melsp_dB_src_trg_std,\\n \\\"min_eval_loss_laplace\\\": min_eval_loss_laplace,\\n \\\"min_eval_loss_laplace_cv\\\": min_eval_loss_laplace_cv,\\n \\\"iter_idx\\\": iter_idx,\\n \\\"min_idx\\\": min_idx,\\n \\\"optimizer\\\": optimizer.state_dict(),\\n \\\"numpy_random_state\\\": numpy_random_state,\\n \\\"torch_random_state\\\": torch_random_state,\\n \\\"iterations\\\": iterations}\\n else:\\n checkpoint = {\\n \\\"model_encoder_melsp\\\": model_encoder_melsp.state_dict(),\\n \\\"model_decoder_melsp\\\": model_decoder_melsp.state_dict(),\\n \\\"model_encoder_excit\\\": model_encoder_excit.state_dict(),\\n \\\"model_decoder_excit\\\": model_decoder_excit.state_dict(),\\n \\\"model_classifier\\\": model_classifier.state_dict(),\\n \\\"model_post\\\": model_post.state_dict(),\\n \\\"min_eval_loss_melsp_dB\\\": min_eval_loss_melsp_dB,\\n \\\"min_eval_loss_melsp_dB_std\\\": min_eval_loss_melsp_dB_std,\\n \\\"min_eval_loss_melsp_cv\\\": min_eval_loss_melsp_cv,\\n \\\"min_eval_loss_melsp\\\": min_eval_loss_melsp,\\n \\\"min_eval_loss_melsp_dB_src_trg\\\": min_eval_loss_melsp_dB_src_trg,\\n \\\"min_eval_loss_melsp_dB_src_trg_std\\\": min_eval_loss_melsp_dB_src_trg_std,\\n \\\"min_eval_loss_laplace\\\": min_eval_loss_laplace,\\n \\\"min_eval_loss_laplace_cv\\\": min_eval_loss_laplace_cv,\\n \\\"iter_idx\\\": iter_idx,\\n \\\"min_idx\\\": min_idx,\\n \\\"optimizer\\\": optimizer.state_dict(),\\n \\\"numpy_random_state\\\": numpy_random_state,\\n \\\"torch_random_state\\\": torch_random_state,\\n \\\"iterations\\\": iterations}\\n if not os.path.exists(checkpoint_dir):\\n os.makedirs(checkpoint_dir)\\n torch.save(checkpoint, checkpoint_dir + \\\"/checkpoint-%d.pkl\\\" % iterations)\\n model_encoder_melsp.cuda()\\n model_decoder_melsp.cuda()\\n model_encoder_excit.cuda()\\n model_decoder_excit.cuda()\\n model_classifier.cuda()\\n model_post.cuda()\\n if model_spkidtr is not None:\\n model_spkidtr.cuda()\\n logging.info(\\\"%d-iter checkpoint created.\\\" % iterations)\",\n \"def save(self, file_prefix, options=None):\\n options = options or checkpoint_options.CheckpointOptions()\\n\\n # IMPLEMENTATION DETAILS: most clients should skip.\\n #\\n # Suffix for any well-formed \\\"checkpoint_prefix\\\", when sharded.\\n # Transformations:\\n # * Users pass in \\\"save_path\\\" in save() and restore(). Say \\\"myckpt\\\".\\n # * checkpoint_prefix gets fed <save_path><sharded_suffix>.\\n #\\n # Example:\\n # During runtime, a temporary directory is first created, which contains\\n # files\\n #\\n # <train dir>/myckpt_temp/\\n # part-?????-of-?????{.index, .data-00000-of-00001}\\n #\\n # Before .save() finishes, they will be (hopefully, atomically) renamed to\\n #\\n # <train dir>/\\n # myckpt{.index, .data-?????-of-?????}\\n #\\n # Filesystems with eventual consistency (such as S3), don't need a\\n # temporary location. Using a temporary directory in those cases might\\n # cause situations where files are not available during copy.\\n #\\n # Users only need to interact with the user-specified prefix, which is\\n # \\\"<train dir>/myckpt\\\" in this case. Save() and Restore() work with the\\n # prefix directly, instead of any physical pathname. (On failure and\\n # subsequent restore, an outdated and orphaned temporary directory can be\\n # safely removed.)\\n with ops.device(\\\"CPU\\\"):\\n sharded_suffix = array_ops.where(\\n string_ops.regex_full_match(file_prefix, \\\"^s3://.*\\\"),\\n constant_op.constant(\\\".part\\\"),\\n constant_op.constant(\\\"_temp/part\\\"))\\n tmp_checkpoint_prefix = string_ops.string_join(\\n [file_prefix, sharded_suffix])\\n registered_paths = {\\n saver_name: registered_saver_filename(file_prefix, saver_name)\\n for saver_name in self._registered_savers\\n }\\n\\n def save_fn():\\n saved_prefixes = []\\n # Save with the registered savers. These run before default savers due to\\n # the API contract.\\n for saver_name, (save_fn, _) in self._registered_savers.items():\\n maybe_saved_prefixes = save_fn(registered_paths[saver_name])\\n if maybe_saved_prefixes is not None:\\n flattened_saved_prefixes = nest.flatten(maybe_saved_prefixes)\\n if not all(\\n tensor_util.is_tf_type(x) and x.dtype == dtypes.string\\n for x in flattened_saved_prefixes):\\n raise ValueError(\\n \\\"Registered saver must return a (maybe empty) list of \\\"\\n f\\\"string type tensors. Got {maybe_saved_prefixes}.\\\")\\n saved_prefixes.extend(flattened_saved_prefixes)\\n\\n # (Default saver) Save with single device savers.\\n num_shards = len(self._single_device_savers)\\n sharded_saves = []\\n num_shards_tensor = constant_op.constant(num_shards, name=\\\"num_shards\\\")\\n last_device = None\\n for shard, (device, saver) in enumerate(\\n sorted(self._single_device_savers.items())):\\n last_device = device\\n with ops.device(saveable_object_util.set_cpu0(device)):\\n shard_prefix = sharded_filename(tmp_checkpoint_prefix, shard,\\n num_shards_tensor)\\n saved_prefixes.append(shard_prefix)\\n with ops.device(device):\\n # _SingleDeviceSaver will use the CPU device when necessary, but\\n # initial read operations should be placed on the SaveableObject's\\n # device.\\n sharded_saves.append(saver.save(shard_prefix, options))\\n\\n with ops.control_dependencies(sharded_saves):\\n # Merge on the io_device if specified, otherwise co-locates the merge op\\n # with the last device used.\\n merge_device = (\\n options.experimental_io_device or\\n saveable_object_util.set_cpu0(last_device))\\n with ops.device(merge_device):\\n # V2 format write path consists of a metadata merge step. Once\\n # merged, attempts to delete the temporary directory,\\n # \\\"<user-fed prefix>_temp\\\".\\n return gen_io_ops.merge_v2_checkpoints(\\n saved_prefixes, file_prefix, delete_old_dirs=True)\\n\\n # Since this will causes a function re-trace on each save, limit this to the\\n # cases where it is needed: eager and when there are multiple tasks/single\\n # device savers. Note that the retrace is needed to ensure we pickup the\\n # latest values of options like experimental_io_device.\\n if context.executing_eagerly() and len(self._single_device_savers) > 1:\\n # Explicitly place the identity op on the first device.\\n @def_function.function(jit_compile=False)\\n def tf_function_save():\\n save_fn()\\n tf_function_save()\\n else:\\n return save_fn()\",\n \"def save_model (model, folder_path, epoch, opt_fn, loss_fn, is_best, multi_gpu=False, verbose=False):\\n\\n last_check_path = os.path.join(folder_path, 'last-checkpoint')\\n best_check_path = os.path.join(folder_path, 'best-checkpoint')\\n\\n if not os.path.exists(last_check_path):\\n if verbose:\\n print ('last-checkpoint folder does not exist. I am creating it!')\\n os.mkdir(last_check_path)\\n else:\\n if verbose:\\n print ('last-checkpoint folder exist! Perfect, I will just use it.')\\n\\n if not os.path.exists(best_check_path):\\n if verbose:\\n print('best-checkpoint folder does not exist. I am creating it!')\\n os.mkdir(best_check_path)\\n else:\\n if verbose:\\n print('best-checkpoint folder exist! Perfect, I will just use it.')\\n\\n info_to_save = {\\n 'epoch': epoch,\\n 'model_state_dict': model.module.state_dict() if multi_gpu else model.state_dict(),\\n 'optimizer_state_dict': opt_fn.state_dict(),\\n 'loss': loss_fn,\\n }\\n\\n torch.save(info_to_save, os.path.join(last_check_path, \\\"last-checkpoint.pth\\\"))\\n\\n if is_best:\\n torch.save(info_to_save, os.path.join(best_check_path, 'best-checkpoint.pth'))\",\n \"def _save(self, step):\\n\\n output_path = self.output_path + '/checkpoints/'\\n if not os.path.isdir(output_path):\\n os.makedirs(output_path)\\n self.saver.save(self.session, save_path=output_path,global_step=step)\",\n \"def checkpoint(self, epoch: int):\\n if self.exp.scheduler_stepper is not None:\\n torch.save(\\n {\\n \\\"model_state_dict\\\": self.exp.model.state_dict(),\\n \\\"optimizer_state_dict\\\": self.exp.optimizer.state_dict(),\\n \\\"scheduler_state_dict\\\": self.exp.scheduler_stepper.scheduler.state_dict(),\\n \\\"Epoch\\\": epoch,\\n },\\n self.exp.path,\\n )\\n else:\\n torch.save(\\n {\\n \\\"model_state_dict\\\": self.exp.model.state_dict(),\\n \\\"optimizer_state_dict\\\": self.exp.optimizer.state_dict(),\\n \\\"Epoch\\\": epoch,\\n },\\n self.exp.path,\\n )\",\n \"def save_checkpoint(state, is_best, checkpoint):\\n filepath = os.path.join(checkpoint, 'last.pth.tar')\\n if not os.path.exists(checkpoint):\\n print(\\\"Checkpoint Directory does not exist! Making directory {}\\\".format(checkpoint))\\n os.mkdir(checkpoint)\\n torch.save(state, filepath)\\n # 如果是最好的checkpoint则以best为文件名保存\\n if is_best:\\n shutil.copyfile(filepath, os.path.join(checkpoint, 'best.pth.tar'))\",\n \"def save(self):\\n\\n pattern = '{}_{}_{}ep.pt' if self.checkpoint_filename_pattern is None else self.checkpoint_filename_pattern\\n filename = pattern.format('sherlock1', time.strftime(\\\"%Y-%m-%d_%H-%M-%S\\\"),\\n self.monitors['loss_train'].num_epochs)\\n full_filename = self.full_path(filename)\\n c = {\\n 'state_dict': self.net.state_dict(),\\n 'optimizer': self.optimizer.state_dict(),\\n 'monitors': self.monitors,\\n 'parent': self.parent,\\n 'args': vars(args) # convert args to dict\\n }\\n torch.save(c, full_filename)\\n if not args.tuning and args.delete and self.last_checkpoint is not None:\\n os.remove(self.last_checkpoint)\\n self.last_checkpoint = full_filename\\n return filename\",\n \"def save_checkpoint(self, name):\\n path = os.path.join(self.params.dump_path, '%s.pth' % name)\\n logger.info(\\\"Saving %s to %s ...\\\" % (name, path))\\n\\n data = {\\n 'epoch': self.epoch,\\n 'best_metrics': self.scores\\n }\\n\\n logger.warning(\\\"Saving model parameters ...\\\")\\n data['model'] = self.encoder.model.state_dict()\\n data['classifier'] = self.proj\\n data['dico_id2word'] = self.data['dico'].id2word\\n data['dico_word2id'] = self.data['dico'].word2id\\n data['dico_counts'] = self.data['dico'].counts\\n # print(self.encoder.pretrain_params)\\n data['params'] = self.encoder.pretrain_params.update({k: v for k, v in self.params.__dict__.items()})\\n\\n torch.save(data, path)\",\n \"def back_up(self, epoch):\\n K.set_value(self._ckpt_saved_epoch, epoch)\\n # Save the model plus CKPT_SAVED_EPOCH variable.\\n if self.write_checkpoint_manager.save():\\n distributed_file_utils.remove_temp_dirpath(\\n self.write_checkpoint_manager.directory,\\n None) #self._model.distribute_strategy)\",\n \"def save_checkpoint(self, checkpoint: str) -> str:\\n\\n # Some model might need to aggregate variables during checkpointing\\n # which requires both the chief and workers to participate in the\\n # allreduce communication protocol.\\n # So we need to call get_state on every remote workers, otherwise\\n # it might get stuck\\n state_refs = [w.get_state.remote() for w in self.remote_workers]\\n\\n state = ray.get(state_refs[0])\\n\\n with open(checkpoint, \\\"wb\\\") as f:\\n SafePickle.dump(state, f)\\n\\n return checkpoint\",\n \"def save_checkpoint(model, optimizer=None, model_name='model', validation_id=None):\\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\\n\\n print_debug('Saving checkpoint: ' + path)\\n\\n model = model.module if type(model) is torch.nn.DataParallel else model\\n\\n checkpoint = {\\n 'model_state_dict': model.state_dict()\\n }\\n\\n if optimizer is not None:\\n checkpoint['optimizer_state_dict'] = optimizer.state_dict()\\n\\n torch.save(checkpoint, path)\",\n \"def saveCheckpoint(self):\\n time_stamp = time.strftime('%Y%m%d%H%M%S', time.gmtime())\\n state_filename = os.path.join(self.saving_dir, 'checkpoint.' + time_stamp + '.pth.tar')\\n mem_filename = os.path.join(self.saving_dir, 'memory.' + time_stamp + '.pth.tar')\\n state = self.getSavingState()\\n memory = {\\n 'memory': self.memory\\n }\\n torch.save(state, state_filename)\\n torch.save(memory, mem_filename)\",\n \"def save_checkpoint(self, path: str, **kwargs):\\n if self.distributed:\\n encoder = self.net_q.module.encoder\\n head = self.net_q.module.head\\n else:\\n encoder = self.net_q.encoder\\n head = self.net_q.head\\n\\n ckpt = {\\n 'encoder': encoder.state_dict(),\\n 'head': head.state_dict(),\\n 'net_ps': self.net_ps.state_dict(),\\n 'net_k': self.net_k.state_dict(),\\n 'queue': self.queue.state_dict(),\\n 'optimizer': self.optimizer.state_dict(),\\n 'scheduler': self.scheduler.state_dict(),\\n }\\n if kwargs:\\n ckpt.update(kwargs)\\n torch.save(ckpt, path)\",\n \"def export(self, last_checkpoint, output_dir):\\r\\n with tf.Session(graph=tf.Graph()) as sess:\\r\\n inputs, outputs = self.build_prediction_image_graph()\\r\\n init_op = tf.global_variables_initializer()\\r\\n sess.run(init_op)\\r\\n trained_saver = tf.train.Saver()\\r\\n trained_saver.restore(sess, last_checkpoint)\\r\\n \\r\\n predict_signature_def = build_signature(inputs, outputs)\\r\\n # Create a saver for writing SavedModel training checkpoints.\\r\\n build = builder.SavedModelBuilder(\\r\\n os.path.join(output_dir, 'saved_model_image_in'))\\r\\n build.add_meta_graph_and_variables(\\r\\n sess, [tag_constants.SERVING],\\r\\n signature_def_map={\\r\\n signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:\\r\\n predict_signature_def\\r\\n },\\r\\n assets_collection=tf.get_collection(tf.GraphKeys.ASSET_FILEPATHS))\\r\\n self.has_exported_image_in = True\\r\\n build.save()\",\n \"def save(self, sess):\\n ckpt_path = os.path.join(self.model.ckpt_dir, 'model')\\n if not os.path.exists(self.model.ckpt_dir):\\n os.makedirs(self.model.ckpt_dir)\\n self.saver.save(sess, ckpt_path, global_step=self.gstep)\",\n \"def save_folder(date_time, sfid, logs_folder, checkpoints_folder):\\n date_now = str(date_time.date())\\n time_now = str(date_time.time())\\n sf = \\\"saved_models/\\\" + date_now + \\\"_\\\" + time_now + \\\"_\\\" \\\\\\n + os.path.basename(__file__).split('.')[0] + '_' + sfid\\n if not os.path.isdir(sf):\\n os.makedirs(sf)\\n\\n lf = sf +'/' + logs_folder\\n if not os.path.isdir(lf):\\n os.makedirs(lf)\\n chkf = sf +'/' +checkpoints_folder\\n if not os.path.isdir(chkf):\\n os.makedirs(chkf)\\n\\n\\n return sf, lf, chkf\",\n \"def save_checkpoint_manual(model: LFADS, path: str):\\n model_wts = [v.numpy() for v in model.trainable_variables]\\n optim_wts = model.optimizer.get_weights()\\n checkpoint = {\\\"model\\\": model_wts, \\\"optimizer\\\": optim_wts}\\n with open(path, \\\"wb\\\") as fout:\\n pickle.dump(checkpoint, fout)\",\n \"def save_checkpoint(self, name, include_optimizers=True):\\n if not self.params.is_master:\\n return\\n path = os.path.join(self.params.dump_path, '%s.pth' % name)\\n logger.info(\\\"Saving %s to %s ...\\\" % (name, path))\\n\\n data = {\\n 'epoch': self.epoch,\\n 'n_total_iter': self.n_total_iter,\\n 'best_metrics': self.best_metrics,\\n 'best_stopping_criterion': self.best_stopping_criterion,\\n }\\n\\n for name in self.MODEL_NAMES:\\n logger.warning(\\\"Saving %s parameters ...\\\" % name)\\n data[name] = getattr(self, name).state_dict()\\n if include_optimizers:\\n for name in self.optimizers.keys():\\n logger.warning(\\\"Saving %s optimizer ...\\\" % name)\\n data['%s_optimizer' % name] = self.optimizers[name].state_dict()\\n\\n # data['dico_id2word'] = self.data['dico'].id2word\\n # data['dico_word2id'] = self.data['dico'].word2id\\n # data['dico_counts'] = self.data['dico'].counts\\n data['params'] = {k: v for k, v in self.params.__dict__.items()}\\n\\n torch.save(data, path)\",\n \"def train_and_save(self, checkpoint_dir):\\n dataset = self._read_dataset(self._train_dataset_path)\\n features, labels = self.get_features_and_labels(dataset)\\n self._model.partial_fit(features, labels, classes=self._classes)\\n checkpoint_path = self._save_model(checkpoint_dir)\\n return checkpoint_path\",\n \"def save_keras_checkpoint(keras_model: tf.keras.Model,\\n save_path: Text,\\n save_format: Text = 'ckpt'\\n ):\\n if save_format == 'ckpt':\\n checkpoint = tf.train.Checkpoint(model=keras_model)\\n manager = tf.train.CheckpointManager(checkpoint,\\n directory=save_path,\\n max_to_keep=1)\\n manager.save()\\n else:\\n keras_model.save(save_path, save_format=save_format)\",\n \"def write_checkpoint(self, checkpoint_id, best=False):\\n assert self.output_dir is not None\\n checkpoint_dir = os.path.join(self.output_dir, 'checkpoints')\\n fname = self.get_model_fname(self.model)\\n checkpoint_file = ''\\n if best:\\n checkpoint_file = 'model_checkpoint_%s.best.pth.tar' % ( fname )\\n else:\\n checkpoint_file = 'model_checkpoint_%s_%03i.pth.tar' % ( fname, checkpoint_id )\\n os.makedirs(checkpoint_dir, exist_ok=True)\\n torch.save(dict(model=self.model.state_dict()),\\n os.path.join(checkpoint_dir, checkpoint_file))\",\n \"def save_ckpt(self, name=None):\\r\\n if name is None:\\r\\n save_path = os.path.join(self.model_dir, \\\"ckpt_epoch{}.pth\\\".format(self.clock.epoch))\\r\\n print(\\\"Checkpoint saved at {}\\\".format(save_path))\\r\\n else:\\r\\n save_path = os.path.join(self.model_dir, \\\"{}.pth\\\".format(name))\\r\\n if isinstance(self.net, nn.DataParallel):\\r\\n torch.save({\\r\\n 'clock': self.clock.make_checkpoint(),\\r\\n 'model_state_dict': self.net.module.cpu().state_dict(),\\r\\n 'optimizer_state_dict': self.optimizer.state_dict(),\\r\\n 'scheduler_state_dict': self.scheduler.state_dict(),\\r\\n }, save_path)\\r\\n else:\\r\\n torch.save({\\r\\n 'clock': self.clock.make_checkpoint(),\\r\\n 'model_state_dict': self.net.cpu().state_dict(),\\r\\n 'optimizer_state_dict': self.optimizer.state_dict(),\\r\\n 'scheduler_state_dict': self.scheduler.state_dict(),\\r\\n }, save_path)\\r\\n self.net.cuda()\",\n \"def save_model(file_name, ep, model, optimizer):\\n\\n torch.save({\\n 'epoch': ep,\\n 'model_state_dict': model.state_dict(),\\n 'optimizer_state_dict': optimizer.state_dict(),\\n }, file_name) \\n \\n return\",\n \"def save_checkpoint(state, is_best, file_path, file_name='checkpoint.pth.tar'):\\n\\n save_path = file_path + '/' + file_name\\n torch.save(state, save_path)\\n if is_best:\\n shutil.copyfile(save_path, file_path + '/model_best.pth.tar')\",\n \"def save_model(self, path, name, epoch=\\\"best\\\"):\\n\\n # Checks if the save directory exists and if not creates it.\\n os.makedirs(path, exist_ok=True)\\n\\n # Saves the model to the save directory.\\n torch.save(self.state_dict(), os.path.join(path, f\\\"{name}_cnn_{str(epoch)}.pt\\\"))\",\n \"def write_checkpoint(self, session):\\n base_save_path = self.params.cp_save_dir+self.params.model_name+\\\"_v\\\"+self.params.version\\n full_save_path = self.full_saver.save(session,\\n save_path=base_save_path,\\n global_step=self.global_step,\\n latest_filename=self.params.cp_latest_filename)\\n self.logger.log_info(\\\"Full model saved in file %s\\\"%full_save_path)\\n return base_save_path\",\n \"def save_session(self):\\n\\n # Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it\\n checkpoint_dir = os.path.abspath(os.path.join(self.FLAGS.model_dir, \\\"checkpoints\\\"))\\n checkpoint_prefix = os.path.join(checkpoint_dir, \\\"model\\\")\\n if not os.path.exists(checkpoint_dir):\\n os.makedirs(checkpoint_dir)\\n current_step = tf.train.global_step(self.session, self.global_step)\\n path = self.saver.save(self.session, checkpoint_prefix, global_step=current_step)\\n print(\\\"Saved model checkpoint to {}\\\\n\\\".format(path))\",\n \"def save(self, model, ema_model, optimizer, epoch, step, best_wer,\\n is_best=False):\\n rank = 0\\n if dist.is_initialized():\\n dist.barrier()\\n rank = dist.get_rank()\\n\\n if rank != 0:\\n return\\n\\n # Checkpoint already saved\\n if not is_best and epoch in self.tracked:\\n return\\n\\n unwrap_ddp = lambda model: getattr(model, 'module', model)\\n state = {\\n 'epoch': epoch,\\n 'step': step,\\n 'best_wer': best_wer,\\n 'state_dict': unwrap_ddp(model).state_dict(),\\n 'ema_state_dict': unwrap_ddp(ema_model).state_dict() if ema_model is not None else None,\\n 'optimizer': optimizer.state_dict(),\\n 'amp': amp.state_dict() if self.use_amp else None,\\n }\\n\\n if is_best:\\n fpath = os.path.join(\\n self.save_dir, f\\\"{self.model_name}_best_checkpoint.pt\\\")\\n else:\\n fpath = os.path.join(\\n self.save_dir, f\\\"{self.model_name}_epoch{epoch}_checkpoint.pt\\\")\\n\\n print_once(f\\\"Saving {fpath}...\\\")\\n torch.save(state, fpath)\\n\\n if not is_best:\\n # Remove old checkpoints; keep milestones and the last two\\n self.tracked[epoch] = fpath\\n for epoch in set(list(self.tracked)[:-2]) - set(self.keep_milestones):\\n try:\\n os.remove(self.tracked[epoch])\\n except:\\n pass\\n del self.tracked[epoch]\",\n \"def save(self, epoch: int, path: str = 'model.pt'):\\n state_dict = {\\n 'model_state_dict': self.state_dict(),\\n 'epoch': epoch,\\n 'ac_optim_dict': self.actor_optimizer.state_dict(),\\n 'critic_optim_dict': self.critic_optimizer.state_dict()\\n }\\n\\n torch.save(state_dict, path)\",\n \"def save_checkpoint(state, filename):\\n torch.save(state, filename) # save checkpoint\",\n \"def save_checkpoint(state, filename='checkpoint.pth.tar'):\\n torch.save(state, filename)\",\n \"def save_model(args,model,epoch):\\n path='./model_'+args.name\\n if not os.path.exists(path):\\n os.mkdir(path)\\n model_name='checkpoint_epoch={}'.format(epoch)\\n filepath=os.path.join(path,model_name)\\n torch.save(model.state_dict(), filepath)\",\n \"def checkpoint(iteration, G, D, opts):\\n ckpt_path = os.path.join(opts.checkpoint_dir, 'ckpt_{:06d}.pth.tar'.format(iteration))\\n torch.save({'G': G.state_dict(),\\n 'D': D.state_dict(),\\n 'iter': iteration}, \\n ckpt_path)\",\n \"def save_model(self, path, name, epoch=\\\"best\\\"):\\n\\n # Checks if the save directory exists and if not creates it.\\n os.makedirs(path, exist_ok=True)\\n\\n # Saves the model to the save directory.\\n torch.save(self.state_dict(), os.path.join(path, f\\\"{name}_sn_{str(epoch)}.pt\\\"))\",\n \"def _save_params(self, output_folder: str, checkpoint: int):\\n arg_params, aux_params = self.module.get_params() # sync aux params across devices\\n self.module.set_params(arg_params, aux_params)\\n self.params = arg_params\\n params_base_fname = C.PARAMS_NAME % checkpoint\\n self.save_params_to_file(os.path.join(output_folder, params_base_fname))\",\n \"def save_checkpoint(self, model):\\n # print(f\\\"save model {self.save_model_path}\\\")\\n torch.save(model.state_dict(), self.save_model_path)\",\n \"def save(self, directory: Optional[str] = None, epoch: Optional[int] = None, filename: Optional[str] = None):\\n if directory is None and self.save_dir:\\n directory = self.save_dir\\n\\n if directory is None:\\n if filename is None:\\n raise ValueError(\\\"The argument `directory` or `filename` must be specified.\\\")\\n else:\\n path = filename\\n else:\\n directory_path = Path(directory)\\n if not directory_path.exists():\\n directory_path.mkdir(parents=True)\\n\\n if epoch is None:\\n epoch_str = ctime().replace(\\\" \\\", \\\"_\\\")\\n else:\\n epoch_str = str(epoch)\\n\\n if not filename:\\n filename = \\\"enchanter_checkpoints_epoch_{}.pth\\\".format(epoch_str)\\n\\n path = str(directory_path / filename)\\n\\n checkpoint = self.save_checkpoint()\\n torch.save(checkpoint, path)\\n\\n model_name = self.model_name()\\n self.experiment.log_model(model_name, str(path))\",\n \"def save_checkpoint(model, is_best, filename='./model/checkpoint.pth.tar'):\\n if is_best:\\n torch.save(model.state_dict(), filename) # save checkpoint\\n else:\\n print (\\\"=> Validation Accuracy did not improve\\\")\",\n \"def save_model(net, epoch, opt):\\r\\n if opt.multi_gpu == True:\\r\\n if epoch % opt.save_by_epoch == 0:\\r\\n torch.save(net.module, './model/epoch%d_batchsize%d.pth' % (epoch, opt.batch_size))\\r\\n print('The trained model is successfully saved at epoch %d' % (epoch))\\r\\n else:\\r\\n if epoch % opt.save_by_epoch == 0:\\r\\n torch.save(net, './model/epoch%d_batchsize%d.pth' % (epoch, opt.batch_size))\\r\\n print('The trained model is successfully saved at epoch %d' % (epoch))\",\n \"def save(self, folder):\\n self.generator.save_weights('%s/generator.h5'%folder)\\n self.critic.save_weights('%s/critic.h5'%folder)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73279613","0.7212068","0.7110705","0.70985615","0.7074814","0.7049468","0.7041478","0.7008442","0.7005684","0.6975668","0.6948612","0.6930357","0.69280964","0.68722343","0.6871008","0.686374","0.6840294","0.67784363","0.6768815","0.6761419","0.6749226","0.67384505","0.6732112","0.6720184","0.67102444","0.6705523","0.6703562","0.66891444","0.6683254","0.6676604","0.66725546","0.666312","0.6655545","0.66503006","0.66315603","0.6630564","0.66268355","0.66161317","0.66081226","0.66043687","0.65996456","0.65916884","0.65914434","0.65832615","0.6582654","0.6577316","0.6575192","0.657489","0.6568904","0.6567614","0.6552253","0.65474266","0.65202785","0.65146106","0.6510118","0.6502318","0.6501114","0.6490838","0.6488277","0.64878345","0.647564","0.6465131","0.6461828","0.64509416","0.6445251","0.6442845","0.64353824","0.64222074","0.6419493","0.64114046","0.6406433","0.640558","0.63988614","0.6395137","0.63782674","0.6364677","0.6336641","0.6334147","0.6323091","0.6320751","0.6313641","0.63102895","0.6294189","0.6290109","0.62840044","0.62817144","0.6278738","0.6278187","0.6263699","0.6256394","0.62560624","0.62558943","0.6254891","0.62507635","0.6224765","0.62199455","0.6214326","0.621228","0.6206325","0.6203553"],"string":"[\n \"0.73279613\",\n \"0.7212068\",\n \"0.7110705\",\n \"0.70985615\",\n \"0.7074814\",\n \"0.7049468\",\n \"0.7041478\",\n \"0.7008442\",\n \"0.7005684\",\n \"0.6975668\",\n \"0.6948612\",\n \"0.6930357\",\n \"0.69280964\",\n \"0.68722343\",\n \"0.6871008\",\n \"0.686374\",\n \"0.6840294\",\n \"0.67784363\",\n \"0.6768815\",\n \"0.6761419\",\n \"0.6749226\",\n \"0.67384505\",\n \"0.6732112\",\n \"0.6720184\",\n \"0.67102444\",\n \"0.6705523\",\n \"0.6703562\",\n \"0.66891444\",\n \"0.6683254\",\n \"0.6676604\",\n \"0.66725546\",\n \"0.666312\",\n \"0.6655545\",\n \"0.66503006\",\n \"0.66315603\",\n \"0.6630564\",\n \"0.66268355\",\n \"0.66161317\",\n \"0.66081226\",\n \"0.66043687\",\n \"0.65996456\",\n \"0.65916884\",\n \"0.65914434\",\n \"0.65832615\",\n \"0.6582654\",\n \"0.6577316\",\n \"0.6575192\",\n \"0.657489\",\n \"0.6568904\",\n \"0.6567614\",\n \"0.6552253\",\n \"0.65474266\",\n \"0.65202785\",\n \"0.65146106\",\n \"0.6510118\",\n \"0.6502318\",\n \"0.6501114\",\n \"0.6490838\",\n \"0.6488277\",\n \"0.64878345\",\n \"0.647564\",\n \"0.6465131\",\n \"0.6461828\",\n \"0.64509416\",\n \"0.6445251\",\n \"0.6442845\",\n \"0.64353824\",\n \"0.64222074\",\n \"0.6419493\",\n \"0.64114046\",\n \"0.6406433\",\n \"0.640558\",\n \"0.63988614\",\n \"0.6395137\",\n \"0.63782674\",\n \"0.6364677\",\n \"0.6336641\",\n \"0.6334147\",\n \"0.6323091\",\n \"0.6320751\",\n \"0.6313641\",\n \"0.63102895\",\n \"0.6294189\",\n \"0.6290109\",\n \"0.62840044\",\n \"0.62817144\",\n \"0.6278738\",\n \"0.6278187\",\n \"0.6263699\",\n \"0.6256394\",\n \"0.62560624\",\n \"0.62558943\",\n \"0.6254891\",\n \"0.62507635\",\n \"0.6224765\",\n \"0.62199455\",\n \"0.6214326\",\n \"0.621228\",\n \"0.6206325\",\n \"0.6203553\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7023109"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":4483,"cells":{"query":{"kind":"string","value":"Initialize the weights of a Pytorch module."},"document":{"kind":"string","value":"def init_weights(m: Union[torch.nn.Conv3d, torch.nn.BatchNorm3d]) -> None:\n import torch\n if isinstance(m, torch.nn.Conv3d):\n torch.nn.init.normal_(m.weight, 0, 0.01)\n elif isinstance(m, torch.nn.BatchNorm3d):\n torch.nn.init.constant_(m.weight, 1)\n torch.nn.init.constant_(m.bias, 0)"},"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_weights(module: nn.Module, name: str, head_bias: float = 0., flax=False):\n if isinstance(module, nn.Linear):\n if name.startswith('head'):\n nn.init.zeros_(module.weight)\n nn.init.constant_(module.bias, head_bias)\n else:\n if flax:\n # Flax defaults\n lecun_normal_(module.weight)\n if module.bias is not None:\n nn.init.zeros_(module.bias)\n else:\n # like MLP init in vit (my original init)\n nn.init.xavier_uniform_(module.weight)\n if module.bias is not None:\n if 'mlp' in name:\n nn.init.normal_(module.bias, std=1e-6)\n else:\n nn.init.zeros_(module.bias)\n elif isinstance(module, nn.Conv2d):\n lecun_normal_(module.weight)\n if module.bias is not None:\n nn.init.zeros_(module.bias)\n elif isinstance(module, (nn.LayerNorm, nn.BatchNorm2d, nn.GroupNorm)):\n nn.init.ones_(module.weight)\n nn.init.zeros_(module.bias)\n elif hasattr(module, 'init_weights'):\n # NOTE if a parent module contains init_weights method, it can override the init of the\n # child modules as this will be called in depth-first order.\n module.init_weights()","def init_weights(self, module):\n if isinstance(module, (torch.nn.Linear, torch.nn.Embedding, torch.nn.LayerNorm)):\n module.weight.data.normal_(mean=0.0, std=self.initializer_range)\n if isinstance(module, (torch.nn.Linear, torch.nn.LayerNorm)) and module.bias is not None:\n module.bias.data.zero_()","def _init_esim_weights(module):\n if isinstance(module, nn.Linear):\n nn.init.xavier_uniform_(module.weight.data)\n nn.init.constant_(module.bias.data, 0.0)\n\n elif isinstance(module, nn.LSTM):\n nn.init.xavier_uniform_(module.weight_ih_l0.data)\n nn.init.orthogonal_(module.weight_hh_l0.data)\n nn.init.constant_(module.bias_ih_l0.data, 0.0)\n nn.init.constant_(module.bias_hh_l0.data, 0.0)\n hidden_size = module.bias_hh_l0.data.shape[0] // 4\n module.bias_hh_l0.data[hidden_size:(2*hidden_size)] = 1.0\n\n if (module.bidirectional):\n nn.init.xavier_uniform_(module.weight_ih_l0_reverse.data)\n nn.init.orthogonal_(module.weight_hh_l0_reverse.data)\n nn.init.constant_(module.bias_ih_l0_reverse.data, 0.0)\n nn.init.constant_(module.bias_hh_l0_reverse.data, 0.0)\n module.bias_hh_l0_reverse.data[hidden_size:(2*hidden_size)] = 1.0","def initialise_weights(self): \n \n def initialise_process(param):\n \n \"\"\"\n Initialises weights of a given parameter following either Xavier or Kaiming uniform or normal processes.\n \n : param (torch.Tensor):\n \n \"\"\"\n \n if self._initialisation_process == 'xavier_uniform':\n tnni.xavier_uniform_(param.data)\n elif self._initialisation_process == 'xavier_normal':\n tnni.xavier_normal_(param.data)\n elif self._initialisation_process == 'kaiming_uniform':\n tnni.kaiming_uniform_(param.data)\n elif self._initialisation_process == 'kaiming_normal':\n tnni.kaiming_normal_(param.data)\n \n if self._initialisation_process is not None:\n for m in self.modules():\n # Embedding\n if type(m) is nn.Embedding:\n tnni.normal_(self.embedding.weight)\n # RNN\n elif type(m) in [nn.GRU, nn.LSTM, nn.RNN]: \n for name, param in m.named_parameters():\n if 'weight_ih' in name:\n initialise_process(param)\n #torch.nn.init.kaiming_normal_(param.data)\n elif 'weight_hh' in name:\n tnni.orthogonal_(param.data)\n elif 'bias' in name:\n # Bias initialised with zero will get the bias from\n # the forget gate\n param.data.fill_(0.0)\n param.data[self._hidden_size:self.directions*self._hidden_size].fill_(1.0)\n # Attention linear layer\n elif type(m) is nn.Linear:\n for name, param in m.named_parameters():\n if 'weight' in name:\n initialise_process(param.data)\n elif 'bias' in name:\n param.data.normal_()","def _init_esim_weights(module):\n if isinstance(module, nn.Linear):\n nn.init.xavier_uniform_(module.weight.data)\n nn.init.constant_(module.bias.data, 0.0)\n\n elif isinstance(module, nn.LSTM):\n nn.init.xavier_uniform_(module.weight_ih_l0.data)\n nn.init.orthogonal_(module.weight_hh_l0.data)\n nn.init.constant_(module.bias_ih_l0.data, 0.0)\n nn.init.constant_(module.bias_hh_l0.data, 0.0)\n hidden_size = module.bias_hh_l0.data.shape[0] // 4\n module.bias_hh_l0.data[hidden_size:(2 * hidden_size)] = 1.0\n\n if module.bidirectional:\n nn.init.xavier_uniform_(module.weight_ih_l0_reverse.data)\n nn.init.orthogonal_(module.weight_hh_l0_reverse.data)\n nn.init.constant_(module.bias_ih_l0_reverse.data, 0.0)\n nn.init.constant_(module.bias_hh_l0_reverse.data, 0.0)\n module.bias_hh_l0_reverse.data[hidden_size:(2 * hidden_size)] = 1.0","def init_weights(self):\n if isinstance(self.pretrained, str):\n logger = get_root_logger()\n logger.info(f'load model from: {self.pretrained}')\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\n elif self.pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n xavier_init(m, distribution='uniform')\n elif isinstance(m, nn.Linear):\n normal_init(m, std=0.01)\n elif isinstance(m, nn.BatchNorm2d):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def _init_weights(self):\n for layer in self.modules():\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\n nn.init.xavier_uniform_(layer.weight)\n if layer.bias is not None:\n nn.init.constant_(layer.bias, 0)\n elif isinstance(layer, nn.BatchNorm1d):\n nn.init.constant_(layer.weight, 1)\n nn.init.constant_(layer.bias, 0)","def _init_weights(self):\n for layer in self.modules():\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\n nn.init.xavier_uniform_(layer.weight)\n if layer.bias is not None:\n nn.init.constant_(layer.bias, 0)\n elif isinstance(layer, nn.BatchNorm1d):\n nn.init.constant_(layer.weight, 1)\n nn.init.constant_(layer.bias, 0)","def _init_weights(self):\n for layer in self.modules():\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\n nn.init.xavier_uniform_(layer.weight)\n if layer.bias is not None:\n nn.init.constant_(layer.bias, 0)\n elif isinstance(layer, nn.BatchNorm1d):\n nn.init.constant_(layer.weight, 1)\n nn.init.constant_(layer.bias, 0)","def weights_init(mod):\n classname = mod.__class__.__name__\n if classname.find('Conv') != -1:\n mod.weight.data.normal_(0.0, 0.02)\n elif classname.find('BatchNorm') != -1:\n mod.weight.data.normal_(1.0, 0.02)\n mod.bias.data.fill_(0)","def init_vit_weights(module: nn.Module, name: str = '', head_bias: float = 0., jax_impl: bool = False):\n if isinstance(module, nn.Linear):\n if name.startswith('head'):\n nn.init.zeros_(module.weight)\n nn.init.constant_(module.bias, head_bias)\n elif name.startswith('pre_logits'):\n lecun_normal_(module.weight)\n nn.init.zeros_(module.bias)\n else:\n if jax_impl:\n nn.init.xavier_uniform_(module.weight)\n if module.bias is not None:\n if 'mlp' in name:\n nn.init.normal_(module.bias, std=1e-6)\n else:\n nn.init.zeros_(module.bias)\n else:\n trunc_normal_(module.weight, std=.02)\n if module.bias is not None:\n nn.init.zeros_(module.bias)\n elif jax_impl and isinstance(module, nn.Conv2d):\n # NOTE conv was left to pytorch default in my original init\n lecun_normal_(module.weight)\n if module.bias is not None:\n nn.init.zeros_(module.bias)\n elif isinstance(module, (nn.LayerNorm, nn.GroupNorm, nn.BatchNorm2d)):\n nn.init.zeros_(module.bias)\n nn.init.ones_(module.weight)","def _weight_initializer(self):\n for m in self.modules():\n if isinstance(m, nn.ConvTranspose2d):\n nn.init.kaiming_normal_(m.weight)\n elif isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1.0)\n nn.init.constant_(m.bias, 0.0)","def _weight_initializer(self):\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n nn.init.kaiming_normal_(m.weight)\n elif isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1.0)\n nn.init.constant_(m.bias, 0.0)","def init_weights(self):\n # We don't use the `init_weights()` function in BaseModule, since it\n # doesn't support the initialization method from `reset_parameters()`\n # in Pytorch.\n if self.with_backbone:\n self.backbone.init_weights()\n\n if self.with_neck:\n for m in self.neck.modules():\n if isinstance(m, _ConvNd) or isinstance(m, _BatchNorm):\n m.reset_parameters()\n\n if self.with_head:\n for m in self.head.modules():\n if isinstance(m, _ConvNd) or isinstance(m, _BatchNorm):\n m.reset_parameters()","def _init_weights(self):\n for m in self.modules():\n if type(m) in {\n nn.Linear,\n nn.Conv3d,\n nn.Conv2d,\n nn.ConvTranspose2d,\n nn.ConvTranspose3d\n }:\n nn.init.kaiming_normal_(\n m.weight.data, a=0, mode='fan_out', nonlinearity='relu',\n )\n if m.bias is not None:\n fan_in, fan_out = \\\n nn.init._calculate_fan_in_and_fan_out(m.weight.data)\n bound = 1 / math.sqrt(fan_out)\n nn.init.normal_(m.bias, -bound, bound)","def init_weights(self):\n with torch.no_grad():\n self._init_weights()","def init_weights(self):\n\n for ch in self.children():\n if issubclass(ch.__class__, torch.nn.Module) and not issubclass(ch.__class__, PreTrainedModel):\n ch.apply(lambda module: self.transformer.__class__._init_weights(self.transformer, module))","def init_params(module):\n\n if isinstance(module, torch.nn.Linear):\n module.weight.data.normal_(mean=0.0, std=0.02)\n if module.bias is not None:\n module.bias.data.zero_()\n if isinstance(module, torch.nn.Embedding):\n module.weight.data.normal_(mean=0.0, std=0.02)\n if module.padding_idx is not None:\n module.weight.data[module.padding_idx].zero_()","def initialize_weights(self):\n weights_initializer.WeightsInitializer.initialize_layer_or_model(\n self._batch)","def init_weights(self):\n if isinstance(self.pretrained, str):\n logger = get_root_logger()\n logger.info(f'load model from: {self.pretrained}')\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\n elif self.pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n xavier_init(m, distribution='uniform')\n elif isinstance(m, nn.Linear):\n normal_init(m, std=0.01)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(model):\n ...","def initialize(self):\n for m in self.modules():\n if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):\n nn.init.xavier_normal_(m.weight)\n if m.bias is not None:\n nn.init.constant_(m.bias, 0)\n elif isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1)\n nn.init.constant_(m.bias, 0)","def _init(module):\n classname = module.__class__.__name__\n if classname.find('Conv') != -1:\n try:\n nn.init.xavier_uniform_(module.weight.data)\n module.bias.data.fill_(0) # May fail.\n except AttributeError:\n pass","def init_weights(self):\n for m in self.modules():\n if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):\n xavier_uniform_(m.weight)\n if m.bias is not None:\n zeros_(m.bias)","def init_weights_(self):\n raise NotImplementedError","def _initialize_weights(self):\n pass","def _initialize_weights(self):\r\n for m in self.modules():\r\n if isinstance(m, nn.Conv2d):\r\n m.weight.data.normal_(0, 0.05)\r\n if m.bias is not None:\r\n m.bias.data.zero_()","def setWeightInitializer(self,weights):\n self.init_w = weights","def init_weights(self, clz):\n for ch in self.children():\n if issubclass(ch.__class__, nn.Module) and not issubclass(ch.__class__, PreTrainedModel):\n ch.apply(lambda module: clz._init_weights(self.lrm, module))","def init_weights(self) -> None:\n nn.init.kaiming_normal_(self._U)\n nn.init.kaiming_normal_(self._W)\n nn.init.kaiming_normal_(self._V)\n\n nn.init.normal_(self._b)","def initialize_weights(self):\n for layer in self._cnn_layers:\n weights_initializer.WeightsInitializer.initialize_layer_or_model(layer)","def init_weights(module, negative_slope=0):\n if isinstance(module, (nn.Conv2d, nn.ConvTranspose2d)):\n nn.init.kaiming_normal_(module.weight.data, negative_slope)\n module.bias.data.zero_()","def weights_init(m):\n if type(m) == torch.nn.Linear:\n m.weight.data.normal_(0.0, 0.02)\n m.bias.data.fill_(0)","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n kaiming_init(m)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n\n if self.zero_init_residual:\n for m in self.modules():\n if isinstance(m, Bottleneck):\n constant_init(m.norm3, 0)\n elif isinstance(m, BasicBlock):\n constant_init(m.norm2, 0)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)","def init_weights(module: nn.Module, gain: float = 1) -> None:\n if isinstance(module, (nn.Linear, nn.Conv2d)):\n nn.init.orthogonal_(module.weight, gain=gain)\n if module.bias is not None:\n module.bias.data.fill_(0.0)","def init_weights(self):\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n xavier_init(m)","def init_weights(self, load_weights=None):\n if load_weights:\n # TODO\n pass\n else:\n # x: lower layer nodes n\n # y: current layer nodes n\n x = self.weights_shape[1]\n y = self.weights_shape[0]\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member","def _initialize_weights(self, inputs):\n if self.data_init:\n self._data_dep_init(inputs)\n else:\n self._init_norm()\n self._initialized = True","def initialize_weights(self):\n tf.nest.map_structure(\n weights_initializer.WeightsInitializer.initialize_layer_or_model,\n self._layer_nest)","def init_weight(self):\n init_layer(self.conv1)\n init_layer(self.conv2)\n init_bn(self.norm1)\n init_bn(self.norm2)","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)\n # Tie weights if needed\n self.tie_weights()","def init_weights(net):\n for m in net.modules():\n if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):\n nn.init.xavier_uniform_(m.weight)\n # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n if m.bias is not None:\n nn.init.constant_(m.bias, 0)\n\n elif isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1)\n nn.init.constant_(m.bias, 0)\n\n return net","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(m):\n if isinstance(m, nn.Linear):\n nn.init.normal_(m.weight, mean=0.1, std=0.01)\n nn.init.constant_(m.bias, 0.0)","def init_weights(m):\n\tif type(m) == nn.Linear:\n\t\ttorch.nn.init.xavier_normal(m.weight)\n\t\tm.bias.data.fill_(0.01)","def init_weight(self):\n init_bn(self.norm0)","def init_weights(self, pretrained: Optional[str] = None) -> None:\n if isinstance(pretrained, str):\n logger = MMLogger.get_current_instance()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n kaiming_init(m)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n if self.zero_init_residual:\n\n for m in self.modules():\n if isinstance(m, Bottleneck):\n constant_init(m.norm3, 0)\n elif isinstance(m, BasicBlock):\n constant_init(m.norm2, 0)\n else:\n raise TypeError('pretrained must be a str or None')","def _reset_weights(m):\n\n nn = import_optional_dependency(\"torch.nn\")\n init = import_optional_dependency(\"torch.nn.init\")\n if isinstance(m, nn.Conv1d):\n init.normal_(m.weight.data)\n if m.bias is not None:\n init.normal_(m.bias.data)\n elif isinstance(m, nn.Conv2d):\n init.xavier_normal_(m.weight.data)\n if m.bias is not None:\n init.normal_(m.bias.data)\n elif isinstance(m, nn.Conv3d):\n init.xavier_normal_(m.weight.data)\n if m.bias is not None:\n init.normal_(m.bias.data)\n elif isinstance(m, nn.ConvTranspose1d):\n init.normal_(m.weight.data)\n if m.bias is not None:\n init.normal_(m.bias.data)\n elif isinstance(m, nn.ConvTranspose2d):\n init.xavier_normal_(m.weight.data)\n if m.bias is not None:\n init.normal_(m.bias.data)\n elif isinstance(m, nn.ConvTranspose3d):\n init.xavier_normal_(m.weight.data)\n if m.bias is not None:\n init.normal_(m.bias.data)\n elif isinstance(m, nn.BatchNorm1d):\n init.normal_(m.weight.data, mean=1, std=0.02)\n init.constant_(m.bias.data, 0)\n elif isinstance(m, nn.BatchNorm2d):\n init.normal_(m.weight.data, mean=1, std=0.02)\n init.constant_(m.bias.data, 0)\n elif isinstance(m, nn.BatchNorm3d):\n init.normal_(m.weight.data, mean=1, std=0.02)\n init.constant_(m.bias.data, 0)\n elif isinstance(m, nn.Linear):\n init.xavier_normal_(m.weight.data)\n init.normal_(m.bias.data)\n elif isinstance(m, nn.LSTM):\n for param in m.parameters():\n if len(param.shape) >= 2:\n init.orthogonal_(param.data)\n else:\n init.normal_(param.data)\n elif isinstance(m, nn.LSTMCell):\n for param in m.parameters():\n if len(param.shape) >= 2:\n init.orthogonal_(param.data)\n else:\n init.normal_(param.data)\n elif isinstance(m, nn.GRU):\n for param in m.parameters():\n if len(param.shape) >= 2:\n init.orthogonal_(param.data)\n else:\n init.normal_(param.data)\n elif isinstance(m, nn.GRUCell):\n for param in m.parameters():\n if len(param.shape) >= 2:\n init.orthogonal_(param.data)\n else:\n init.normal_(param.data)","def init_weights(self):\n\n params = torch.load(self.resnet_weight)\n\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\n\n\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\n self.fc3.out_features)\n self.fc3.weight.data.uniform_(-r, r)\n self.fc3.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\n self.fc4.out_features)\n self.fc4.weight.data.uniform_(-r, r)\n self.fc4.bias.data.fill_(0)","def init_weights(self):\n self.transformer.init_weights()\n if self.loss_cls.use_sigmoid:\n bias_init = bias_init_with_prob(0.01)\n for m in self.cls_branches:\n nn.init.constant_(m[-1].bias, bias_init)","def init_weights(self, pretrained=None):\n if pretrained is not None:\n self.pretrained = pretrained\n self.backbone.init_weights(self.pretrained)\n self.mesh_head.init_weights()\n if self.with_gan:\n self.discriminator.init_weights()","def weight_initialization(m: nn.Module) -> None:\n if type(m) == nn.Linear:\n # nn.init.xavier_uniform_(m.weight, np.sqrt(2.)) # gain is sqrt(2) because we use ReLU\n nn.init.kaiming_uniform_(m.weight, a=np.sqrt(5))\n # nn.init.uniform(m.weight, 0., 0.)","def init_weights(self):\n self._q_neuron.h(self._weights) \n self._q_neuron.x(self._weights)","def init_weights(network):\n for m in network.modules():\n # normal convblock and skip convblock initialisation\n if isinstance(m, (ConvBlock, ConvBlockSkip)):\n if network.weights_init == 'normal':\n torch.nn.init.normal_(m.conv1.weight)\n torch.nn.init.normal_(m.conv2.weight)\n elif network.weights_init == 'orthogonal':\n torch.nn.init.orthogonal_(m.conv1.weight)\n torch.nn.init.orthogonal_(m.conv2.weight)\n elif network.weights_init == 'xavier_uniform':\n torch.nn.init.xavier_uniform_(m.conv1.weight)\n torch.nn.init.xavier_uniform_(m.conv2.weight)\n elif network.weights_init == 'xavier_normal':\n torch.nn.init.xavier_normal_(m.conv1.weight)\n torch.nn.init.xavier_normal_(m.conv2.weight)\n elif network.weights_init == 'kaiming_uniform':\n torch.nn.init.kaiming_uniform_(m.conv1.weight)\n torch.nn.init.kaiming_uniform_(m.conv2.weight)\n elif network.weights_init == 'kaiming_normal':\n torch.nn.init.kaiming_normal_(m.conv1.weight)\n torch.nn.init.kaiming_normal_(m.conv2.weight)\n m.conv1.bias.data.fill_(0.0)\n m.conv2.bias.data.fill_(0.0)\n # fixup block initialisation (see fixup paper for details)\n elif isinstance(m, ConvBlockFixup):\n nn.init.normal_(m.conv1.weight, mean=0, std=np.sqrt(\n 2 / (m.conv1.weight.shape[0] * np.prod(m.conv1.weight.shape[2:]))) * network.nb_conv_blocks ** (-0.5))\n nn.init.constant_(m.conv2.weight, 0)\n # linear layers\n elif isinstance(m, nn.Linear):\n if network.use_fixup:\n nn.init.constant_(m.weight, 0)\n elif network.weights_init == 'normal':\n torch.nn.init.normal_(m.weight)\n elif network.weights_init == 'orthogonal':\n torch.nn.init.orthogonal_(m.weight)\n elif network.weights_init == 'xavier_uniform':\n torch.nn.init.xavier_uniform_(m.weight)\n elif network.weights_init == 'xavier_normal':\n torch.nn.init.xavier_normal_(m.weight)\n elif network.weights_init == 'kaiming_uniform':\n torch.nn.init.kaiming_uniform_(m.weight)\n elif network.weights_init == 'kaiming_normal':\n torch.nn.init.kaiming_normal_(m.weight)\n nn.init.constant_(m.bias, 0)\n # LSTM initialisation\n elif isinstance(m, nn.LSTM):\n for name, param in m.named_parameters():\n if 'weight_ih' in name:\n if network.weights_init == 'normal':\n torch.nn.init.normal_(param.data)\n elif network.weights_init == 'orthogonal':\n torch.nn.init.orthogonal_(param.data)\n elif network.weights_init == 'xavier_uniform':\n torch.nn.init.xavier_uniform_(param.data)\n elif network.weights_init == 'xavier_normal':\n torch.nn.init.xavier_normal_(param.data)\n elif network.weights_init == 'kaiming_uniform':\n torch.nn.init.kaiming_uniform_(param.data)\n elif network.weights_init == 'kaiming_normal':\n torch.nn.init.kaiming_normal_(param.data)\n elif 'weight_hh' in name:\n if network.weights_init == 'normal':\n torch.nn.init.normal_(param.data)\n elif network.weights_init == 'orthogonal':\n torch.nn.init.orthogonal_(param.data)\n elif network.weights_init == 'xavier_uniform':\n torch.nn.init.xavier_uniform_(param.data)\n elif network.weights_init == 'xavier_normal':\n torch.nn.init.xavier_normal_(param.data)\n elif network.weights_init == 'kaiming_uniform':\n torch.nn.init.kaiming_uniform_(param.data)\n elif network.weights_init == 'kaiming_normal':\n torch.nn.init.kaiming_normal_(param.data)\n elif 'bias' in name:\n param.data.fill_(0.0)\n return network","def init_parameters(module: nn.Module):\n for m in module.modules():\n if isinstance(m, nn.Conv2d):\n # todo: check if fan_out is valid\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n elif isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1)\n nn.init.constant_(m.bias, 0)","def weights_init(model):\n classname = model.__class__.__name__\n if classname.find('Conv') != -1:\n nn.init.normal_(model.weight.data, 0.0, 0.02)\n elif classname.find('BatchNorm') != -1:\n nn.init.normal_(model.weight.data, 1.0, 0.02)\n nn.init.constant_(model.bias.data, 0)","def weights_init(self, m):\n if isinstance(m, nn.Conv1d):\n torch.nn.init.xavier_uniform(m.weight.data)\n m.bias.data.fill_(0.0)\n if isinstance(m, nn.LSTM):\n torch.nn.init.xavier_uniform(m.weight_ih_l0)\n torch.nn.init.orthogonal(m.weight_hh_l0)\n for names in m._all_weights:\n for name in filter(lambda n: \"bias\" in n, names):\n bias = getattr(m, name)\n n = bias.size(0)\n start, end = n // 4, n // 2\n bias.data[start:end].fill_(1.0)\n m.bias_ih_l0.data.fill_(0.0)","def initialize_weights(model: nn.Module, transformer: bool = False) -> None:\n for param in model.parameters():\n if param.dim() == 1:\n if transformer:\n nn.init.constant_(param, 0.01)\n else:\n nn.init.constant_(param, 0)\n else:\n nn.init.xavier_normal_(param)","def initialize_weights(m):\n if isinstance(m, nn.Linear) or isinstance(m, nn.ConvTranspose2d):\n init.xavier_uniform(m.weight.data)","def init_weights(self):\n\n super().init_weights()\n\n init_type = None if self.init_cfg is None else self.init_cfg.get(\n 'type', None)\n if init_type != 'Pretrained' and self.with_tsa:\n for module in [\n self.fusion.feat_fusion, self.fusion.spatial_attn1,\n self.fusion.spatial_attn2, self.fusion.spatial_attn3,\n self.fusion.spatial_attn4, self.fusion.spatial_attn_l1,\n self.fusion.spatial_attn_l2, self.fusion.spatial_attn_l3,\n self.fusion.spatial_attn_add1\n ]:\n kaiming_init(\n module.conv,\n a=0.1,\n mode='fan_out',\n nonlinearity='leaky_relu',\n bias=0,\n distribution='uniform')","def weights_init(m):\n if(type(m) == nn.ConvTranspose2d or type(m) == nn.Conv2d):\n nn.init.normal_(m.weight.data, 0.0, 0.02)\n elif(type(m) == nn.BatchNorm2d):\n nn.init.normal_(m.weight.data, 1.0, 0.02)\n nn.init.constant_(m.bias.data, 0)","def weights_init(m):\n if(type(m) == nn.ConvTranspose2d or type(m) == nn.Conv2d):\n nn.init.normal_(m.weight.data, 0.0, 0.02)\n elif(type(m) == nn.BatchNorm2d):\n nn.init.normal_(m.weight.data, 1.0, 0.02)\n nn.init.constant_(m.bias.data, 0)","def init_weights(self):\n \n self.w = np.random.randn(self.D) / np.sqrt(self.D)","def init_weights(self, init_w=3e-3):\n self.l3.weight.data.uniform_(-init_w, init_w)\n self.l3.bias.data.uniform_(-init_w, init_w)","def init_weights(self, init_w=3e-3):\n self.l3.weight.data.uniform_(-init_w, init_w)\n self.l3.bias.data.uniform_(-init_w, init_w)","def _init_weights(self):\n nn.init.xavier_normal_(self.out.weight)","def init_weights(m):\n if isinstance(m, nn.Conv2d):\n # Note that there is no bias due to BN\n fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n m.weight.data.normal_(mean=0.0, std=np.sqrt(2.0 / fan_out))\n elif isinstance(m, nn.BatchNorm2d):\n zero_init_gamma = cfg.BN.ZERO_INIT_FINAL_GAMMA\n zero_init_gamma = hasattr(m, \"final_bn\") and m.final_bn and zero_init_gamma\n m.weight.data.fill_(0.0 if zero_init_gamma else 1.0)\n m.bias.data.zero_()\n elif isinstance(m, nn.Linear):\n m.weight.data.normal_(mean=0.0, std=0.01)\n m.bias.data.zero_()","def init_weights(self, pretrained=None):\n self.online_backbone.init_weights() # backbone\n for online_neck in self.online_necks:\n online_neck.init_weights(init_linear='kaiming') # projection\n\n for param_ol, param_tgt in zip(self.online_backbone.parameters(),\n self.target_backbone.parameters()):\n param_tgt.data.copy_(param_ol.data)\n for param_ol, param_tgt in zip(self.online_necks.parameters(),\n self.target_necks.parameters()):\n param_tgt.data.copy_(param_ol.data)\n # init the predictor in the head\n for head in self.heads:\n head.init_weights()","def init_weights(m):\n if isinstance(m, nn.Conv2d):\n # Note that there is no bias due to BN\n fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n m.weight.data.normal_(mean=0.0, std=math.sqrt(2.0 / fan_out))\n elif isinstance(m, nn.BatchNorm2d):\n zero_init_gamma = cfg.BN.ZERO_INIT_FINAL_GAMMA\n zero_init_gamma = hasattr(m, \"final_bn\") and m.final_bn and zero_init_gamma\n m.weight.data.fill_(0.0 if zero_init_gamma else 1.0)\n m.bias.data.zero_()\n elif isinstance(m, nn.Linear):\n m.weight.data.normal_(mean=0.0, std=0.01)\n m.bias.data.zero_()","def init_weights(self, pretrained=None):\n if pretrained is not None:\n self.pretrained = pretrained\n self.backbone.init_weights(self.pretrained)\n if self.with_necks:\n for neck in self.necks:\n if hasattr(neck, 'init_weights'):\n neck.init_weights()\n for head in self.heads:\n if hasattr(head, 'init_weights'):\n head.init_weights()","def initialize_NN(self, m):\n\n if type(m) == nn.Linear:\n nn.init.xavier_uniform_(m.weight)\n # print(m.weight)","def initialize_weights(self, weights_initializer, bias_initializer):\n wshapes = [\n [self.input_size, self.hidden_size[0]],\n [self.hidden_size[0], self.hidden_size[1]],\n [self.hidden_size[1], self.output_size]\n ]\n\n bshapes = [\n [1, self.hidden_size[0]],\n [1, self.hidden_size[1]],\n [1, self.output_size]\n ]\n\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\n\n self.trainable_variables = self.weights + self.biases","def init_weights(self):\r\n constant_init(self.sampling_offsets, 0.)\r\n thetas = torch.arange(\r\n self.num_heads,\r\n dtype=torch.float32) * (2.0 * math.pi / self.num_heads)\r\n grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)\r\n grid_init = (grid_init /\r\n grid_init.abs().max(-1, keepdim=True)[0]).view(\r\n self.num_heads, 1, 1,\r\n 2).repeat(1, self.num_levels, self.num_points, 1)\r\n for i in range(self.num_points):\r\n grid_init[:, :, i, :] *= i + 1\r\n\r\n self.sampling_offsets.bias.data = grid_init.view(-1)\r\n constant_init(self.attention_weights, val=0., bias=0.)\r\n xavier_init(self.value_proj, distribution='uniform', bias=0.)\r\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\r\n self._is_init = True","def init_weights(self, pretrained=None):\n if pretrained is not None:\n self.pretrained = pretrained\n for modal in self.modality:\n getattr(self.backbone, modal).init_weights(self.pretrained.get(modal, None))\n if hasattr(self, 'neck'):\n self.neck.init_weights()\n if hasattr(self, 'cls_head'):\n self.cls_head.init_weights()","def init_weights(self, dims):\n self.W = np.random.normal(size=dims) * 0.0001","def __init__(self, z_dim, initailize_weights=True):\n super().__init__()\n self.z_dim = z_dim\n\n self.proprio_encoder = nn.Sequential(\n nn.Linear(8, 32),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Linear(32, 64),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Linear(64, 128),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Linear(128, 2 * self.z_dim),\n nn.LeakyReLU(0.1, inplace=True),\n )\n\n if initailize_weights:\n init_weights(self.modules())","def __init__(self, weights):\n self._weights = weights","def init_bert_params(module):\n\n if isinstance(module, nn.Linear):\n module.weight.data.normal_(mean=0.0, std=0.02)\n if module.bias is not None:\n module.bias.data.zero_()\n if isinstance(module, nn.Embedding):\n module.weight.data.normal_(mean=0.0, std=0.02)\n if module.padding_idx is not None:\n module.weight.data[module.padding_idx].zero_()\n if isinstance(module, MultiheadAttention):\n module.in_proj_weight.data.normal_(mean=0.0, std=0.02)","def initialise_parameters(self):\n # Weights\n init = select_w_init(self.w_init)\n if self.w_gain:\n gain = nn.init.calculate_gain('relu')\n init(self.relations, gain=gain)\n else:\n init(self.relations)\n\n # Biases\n if self.b_init:\n init = select_b_init(self.b_init)\n init(self.sbias)\n init(self.pbias)\n init(self.obias)","def init_weights(model, fc_init_std=0.01):\n for m in model.modules():\n if isinstance(m, nn.Conv3d):\n \"\"\"\n Follow the initialization method proposed in:\n {He, Kaiming, et al.\n \"Delving deep into rectifiers: Surpassing human-level\n performance on imagenet classification.\"\n arXiv preprint arXiv:1502.01852 (2015)}\n \"\"\"\n c2_msra_fill(m, nonlinearity=('relu', 'leaky_relu')[0])\n # c2_xavier_fill(m)\n # nn.init.xavier_normal_(m.weight)\n # nn.init.xavier_uniform_(m.weight)\n # if m.bias is not None: # pyre-ignore\n # nn.init.constant_(m.bias, 0)\n elif isinstance(m, nn.BatchNorm3d) or isinstance(m, nn.InstanceNorm3d):\n m.weight.data.fill_(1.0)\n m.bias.data.zero_()\n if isinstance(m, nn.Linear): # This assumes nn.Linear is the final layers\n # TODO check to see if this is effective in this architecture since the final is a conv3d\n m.weight.data.normal_(mean=0.0, std=fc_init_std)\n m.bias.data.zero_()","def InitWeights(self):\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\n self.w0 = -1 + 2 * np.random.rand()","def _set_weights(self):\n self.Wc = torch.mm(self.TP.T, self.W).mm(self.TP)","def weights_init(m):\n if (\n isinstance(m, nn.Linear)\n or isinstance(m, nn.EmbeddingBag)\n or isinstance(m, nn.Embedding)\n or isinstance(m, SparseLinear)\n ):\n nn.init.xavier_normal_(m.weight)","def _initialize_weights(self):\n for _, cell in self.cells_and_names():\n if isinstance(cell, nn.Conv2d):\n cell.weight.set_data(orthogonal(cell.weight.shape, 0.6))\n if cell.bias is not None:\n cell.bias.set_data(\n init.initializer(init.Constant(0.01), cell.bias.shape,\n cell.bias.dtype))","def init_weights2(net):\n\tfor m in net.modules():\n\t\tif isinstance(m, nn.Conv2d):\n\t\t\tnn.init.xavier_uniform_(m.weight)\n\t\t\tif m.bias is not None:\n\t\t\t\tnn.init.constant_(m.bias, 0)\n\t\t\t\n\t\telif isinstance(m, nn.BatchNorm2d):\n\t\t\tnn.init.constant_(m.weight, 1)\n\t\t\tnn.init.constant_(m.bias, 0)\n\t\t\n\t\telif isinstance(m, nn.Linear):\n\t\t\tnn.init.xavier_uniform_(m.weight)\n\n\t\t\tif m.bias is not None:\n\t\t\t\tnn.init.constant_(m.bias, 0)\n\n\treturn net","def init_weights(net, init_gain=0.02):\n def init_func(m): # define the initialization function\n classname = m.__class__.__name__\n if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):\n init.normal_(m.weight.data, 0.0, init_gain)\n if hasattr(m, 'bias') and m.bias is not None:\n init.constant_(m.bias.data, 0.0)\n\n print('initialize network')\n net.apply(init_func) # apply the initialization function <init_func>","def initialize_weights(self, seed=None):\r\n if seed!=None:\r\n np.random.seed(seed)\r\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)","def _init_modules(self, pretrained_weights=None):\n if pretrained_weights is None:\n if cfg.MODEL.LOAD_PRETRAINED_BACKBONE_WEIGHTS:\n print(\"\\n-------------------------------------------\")\n print(\"Load pre-trained ImageNet weights\")\n print(\"\\n-------------------------------------------\")\n weight_utils.load_caffe2_pretrained_weights(self, cfg.MODEL.PRETRAINED_BACKBONE_WEIGHTS)\n return\n\n pretrained_detectron = torch.load(pretrained_weights)\n\n if cfg.RPN.RPN_ON:\n load_layers = ['Conv_Body', 'RPN']\n else:\n load_layers = ['Conv_Body']\n\n mapping, _ = self.detectron_weight_mapping()\n state_dict = {}\n ckpt = pretrained_detectron['model']\n for name in ckpt:\n if name.split('.')[0] in load_layers:\n if mapping[name]:\n state_dict[name] = ckpt[name]\n self.load_state_dict(state_dict, strict=False)\n del pretrained_detectron\n torch.cuda.empty_cache()","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self):\r\n self.embedding.weight.data.uniform_(-0.1, 0.1)\r\n self.fc.bias.data.fill_(0)\r\n self.fc.weight.data.uniform_(-0.1, 0.1)","def initialize_weights(self, seed=None):\n if seed != None:\n np.random.seed(seed)\n self.weights = np.random.randn(self.number_of_nodes, self.input_dimensions)","def init_model(self, model_init):\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n if model_init == 'he_fout':\n n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n m.weight.data.normal_(0, math.sqrt(2.0 / n))\n elif model_init == 'he_fin':\n n = m.kernel_size[0] * m.kernel_size[1] * m.in_channels\n m.weight.data.normal_(0, math.sqrt(2.0 / n))\n else:\n raise NotImplementedError\n if m.bias is not None:\n m.bias.data.zero_()\n elif isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.BatchNorm1d):\n m.weight.data.fill_(1)\n m.bias.data.zero_()\n elif isinstance(m, nn.Linear):\n stdv = 1.0 / math.sqrt(m.weight.size(1))\n m.weight.data.uniform_(-stdv, stdv)\n if m.bias is not None:\n m.bias.data.zero_()","def __init__(self, num_parameters=1, init=0.25):\n super(PReLU, self).__init__()\n self.num_parameters = num_parameters\n self.weight = Parameter(Tensor(num_parameters).fill_(init))","def initWeights(self):\n self.weights = []\n self.bias = []\n for i, dim in enumerate(self.dimensions[1:]):\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\n self.bias.append(np.random.uniform(-1,1,dim))","def init_weights(self, pretrained=None):\n\n super(EncoderDecoder_gan, self).init_weights(pretrained)\n self.backbone.init_weights(pretrained=pretrained)\n self.backbone_gan.init_weights(pretrained=pretrained)\n self.decode_head.init_weights()\n # init GAN\n # self.discriminator.init_weight()\n # self.G_head.init_weights()\n if self.with_auxiliary_head:\n if isinstance(self.auxiliary_head, nn.ModuleList):\n for aux_head in self.auxiliary_head:\n aux_head.init_weights()\n else:\n self.auxiliary_head.init_weights()"],"string":"[\n \"def _init_weights(module: nn.Module, name: str, head_bias: float = 0., flax=False):\\n if isinstance(module, nn.Linear):\\n if name.startswith('head'):\\n nn.init.zeros_(module.weight)\\n nn.init.constant_(module.bias, head_bias)\\n else:\\n if flax:\\n # Flax defaults\\n lecun_normal_(module.weight)\\n if module.bias is not None:\\n nn.init.zeros_(module.bias)\\n else:\\n # like MLP init in vit (my original init)\\n nn.init.xavier_uniform_(module.weight)\\n if module.bias is not None:\\n if 'mlp' in name:\\n nn.init.normal_(module.bias, std=1e-6)\\n else:\\n nn.init.zeros_(module.bias)\\n elif isinstance(module, nn.Conv2d):\\n lecun_normal_(module.weight)\\n if module.bias is not None:\\n nn.init.zeros_(module.bias)\\n elif isinstance(module, (nn.LayerNorm, nn.BatchNorm2d, nn.GroupNorm)):\\n nn.init.ones_(module.weight)\\n nn.init.zeros_(module.bias)\\n elif hasattr(module, 'init_weights'):\\n # NOTE if a parent module contains init_weights method, it can override the init of the\\n # child modules as this will be called in depth-first order.\\n module.init_weights()\",\n \"def init_weights(self, module):\\n if isinstance(module, (torch.nn.Linear, torch.nn.Embedding, torch.nn.LayerNorm)):\\n module.weight.data.normal_(mean=0.0, std=self.initializer_range)\\n if isinstance(module, (torch.nn.Linear, torch.nn.LayerNorm)) and module.bias is not None:\\n module.bias.data.zero_()\",\n \"def _init_esim_weights(module):\\n if isinstance(module, nn.Linear):\\n nn.init.xavier_uniform_(module.weight.data)\\n nn.init.constant_(module.bias.data, 0.0)\\n\\n elif isinstance(module, nn.LSTM):\\n nn.init.xavier_uniform_(module.weight_ih_l0.data)\\n nn.init.orthogonal_(module.weight_hh_l0.data)\\n nn.init.constant_(module.bias_ih_l0.data, 0.0)\\n nn.init.constant_(module.bias_hh_l0.data, 0.0)\\n hidden_size = module.bias_hh_l0.data.shape[0] // 4\\n module.bias_hh_l0.data[hidden_size:(2*hidden_size)] = 1.0\\n\\n if (module.bidirectional):\\n nn.init.xavier_uniform_(module.weight_ih_l0_reverse.data)\\n nn.init.orthogonal_(module.weight_hh_l0_reverse.data)\\n nn.init.constant_(module.bias_ih_l0_reverse.data, 0.0)\\n nn.init.constant_(module.bias_hh_l0_reverse.data, 0.0)\\n module.bias_hh_l0_reverse.data[hidden_size:(2*hidden_size)] = 1.0\",\n \"def initialise_weights(self): \\n \\n def initialise_process(param):\\n \\n \\\"\\\"\\\"\\n Initialises weights of a given parameter following either Xavier or Kaiming uniform or normal processes.\\n \\n : param (torch.Tensor):\\n \\n \\\"\\\"\\\"\\n \\n if self._initialisation_process == 'xavier_uniform':\\n tnni.xavier_uniform_(param.data)\\n elif self._initialisation_process == 'xavier_normal':\\n tnni.xavier_normal_(param.data)\\n elif self._initialisation_process == 'kaiming_uniform':\\n tnni.kaiming_uniform_(param.data)\\n elif self._initialisation_process == 'kaiming_normal':\\n tnni.kaiming_normal_(param.data)\\n \\n if self._initialisation_process is not None:\\n for m in self.modules():\\n # Embedding\\n if type(m) is nn.Embedding:\\n tnni.normal_(self.embedding.weight)\\n # RNN\\n elif type(m) in [nn.GRU, nn.LSTM, nn.RNN]: \\n for name, param in m.named_parameters():\\n if 'weight_ih' in name:\\n initialise_process(param)\\n #torch.nn.init.kaiming_normal_(param.data)\\n elif 'weight_hh' in name:\\n tnni.orthogonal_(param.data)\\n elif 'bias' in name:\\n # Bias initialised with zero will get the bias from\\n # the forget gate\\n param.data.fill_(0.0)\\n param.data[self._hidden_size:self.directions*self._hidden_size].fill_(1.0)\\n # Attention linear layer\\n elif type(m) is nn.Linear:\\n for name, param in m.named_parameters():\\n if 'weight' in name:\\n initialise_process(param.data)\\n elif 'bias' in name:\\n param.data.normal_()\",\n \"def _init_esim_weights(module):\\n if isinstance(module, nn.Linear):\\n nn.init.xavier_uniform_(module.weight.data)\\n nn.init.constant_(module.bias.data, 0.0)\\n\\n elif isinstance(module, nn.LSTM):\\n nn.init.xavier_uniform_(module.weight_ih_l0.data)\\n nn.init.orthogonal_(module.weight_hh_l0.data)\\n nn.init.constant_(module.bias_ih_l0.data, 0.0)\\n nn.init.constant_(module.bias_hh_l0.data, 0.0)\\n hidden_size = module.bias_hh_l0.data.shape[0] // 4\\n module.bias_hh_l0.data[hidden_size:(2 * hidden_size)] = 1.0\\n\\n if module.bidirectional:\\n nn.init.xavier_uniform_(module.weight_ih_l0_reverse.data)\\n nn.init.orthogonal_(module.weight_hh_l0_reverse.data)\\n nn.init.constant_(module.bias_ih_l0_reverse.data, 0.0)\\n nn.init.constant_(module.bias_hh_l0_reverse.data, 0.0)\\n module.bias_hh_l0_reverse.data[hidden_size:(2 * hidden_size)] = 1.0\",\n \"def init_weights(self):\\n if isinstance(self.pretrained, str):\\n logger = get_root_logger()\\n logger.info(f'load model from: {self.pretrained}')\\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\\n elif self.pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n xavier_init(m, distribution='uniform')\\n elif isinstance(m, nn.Linear):\\n normal_init(m, std=0.01)\\n elif isinstance(m, nn.BatchNorm2d):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def _init_weights(self):\\n for layer in self.modules():\\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\\n nn.init.xavier_uniform_(layer.weight)\\n if layer.bias is not None:\\n nn.init.constant_(layer.bias, 0)\\n elif isinstance(layer, nn.BatchNorm1d):\\n nn.init.constant_(layer.weight, 1)\\n nn.init.constant_(layer.bias, 0)\",\n \"def _init_weights(self):\\n for layer in self.modules():\\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\\n nn.init.xavier_uniform_(layer.weight)\\n if layer.bias is not None:\\n nn.init.constant_(layer.bias, 0)\\n elif isinstance(layer, nn.BatchNorm1d):\\n nn.init.constant_(layer.weight, 1)\\n nn.init.constant_(layer.bias, 0)\",\n \"def _init_weights(self):\\n for layer in self.modules():\\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\\n nn.init.xavier_uniform_(layer.weight)\\n if layer.bias is not None:\\n nn.init.constant_(layer.bias, 0)\\n elif isinstance(layer, nn.BatchNorm1d):\\n nn.init.constant_(layer.weight, 1)\\n nn.init.constant_(layer.bias, 0)\",\n \"def weights_init(mod):\\n classname = mod.__class__.__name__\\n if classname.find('Conv') != -1:\\n mod.weight.data.normal_(0.0, 0.02)\\n elif classname.find('BatchNorm') != -1:\\n mod.weight.data.normal_(1.0, 0.02)\\n mod.bias.data.fill_(0)\",\n \"def init_vit_weights(module: nn.Module, name: str = '', head_bias: float = 0., jax_impl: bool = False):\\n if isinstance(module, nn.Linear):\\n if name.startswith('head'):\\n nn.init.zeros_(module.weight)\\n nn.init.constant_(module.bias, head_bias)\\n elif name.startswith('pre_logits'):\\n lecun_normal_(module.weight)\\n nn.init.zeros_(module.bias)\\n else:\\n if jax_impl:\\n nn.init.xavier_uniform_(module.weight)\\n if module.bias is not None:\\n if 'mlp' in name:\\n nn.init.normal_(module.bias, std=1e-6)\\n else:\\n nn.init.zeros_(module.bias)\\n else:\\n trunc_normal_(module.weight, std=.02)\\n if module.bias is not None:\\n nn.init.zeros_(module.bias)\\n elif jax_impl and isinstance(module, nn.Conv2d):\\n # NOTE conv was left to pytorch default in my original init\\n lecun_normal_(module.weight)\\n if module.bias is not None:\\n nn.init.zeros_(module.bias)\\n elif isinstance(module, (nn.LayerNorm, nn.GroupNorm, nn.BatchNorm2d)):\\n nn.init.zeros_(module.bias)\\n nn.init.ones_(module.weight)\",\n \"def _weight_initializer(self):\\n for m in self.modules():\\n if isinstance(m, nn.ConvTranspose2d):\\n nn.init.kaiming_normal_(m.weight)\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1.0)\\n nn.init.constant_(m.bias, 0.0)\",\n \"def _weight_initializer(self):\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n nn.init.kaiming_normal_(m.weight)\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1.0)\\n nn.init.constant_(m.bias, 0.0)\",\n \"def init_weights(self):\\n # We don't use the `init_weights()` function in BaseModule, since it\\n # doesn't support the initialization method from `reset_parameters()`\\n # in Pytorch.\\n if self.with_backbone:\\n self.backbone.init_weights()\\n\\n if self.with_neck:\\n for m in self.neck.modules():\\n if isinstance(m, _ConvNd) or isinstance(m, _BatchNorm):\\n m.reset_parameters()\\n\\n if self.with_head:\\n for m in self.head.modules():\\n if isinstance(m, _ConvNd) or isinstance(m, _BatchNorm):\\n m.reset_parameters()\",\n \"def _init_weights(self):\\n for m in self.modules():\\n if type(m) in {\\n nn.Linear,\\n nn.Conv3d,\\n nn.Conv2d,\\n nn.ConvTranspose2d,\\n nn.ConvTranspose3d\\n }:\\n nn.init.kaiming_normal_(\\n m.weight.data, a=0, mode='fan_out', nonlinearity='relu',\\n )\\n if m.bias is not None:\\n fan_in, fan_out = \\\\\\n nn.init._calculate_fan_in_and_fan_out(m.weight.data)\\n bound = 1 / math.sqrt(fan_out)\\n nn.init.normal_(m.bias, -bound, bound)\",\n \"def init_weights(self):\\n with torch.no_grad():\\n self._init_weights()\",\n \"def init_weights(self):\\n\\n for ch in self.children():\\n if issubclass(ch.__class__, torch.nn.Module) and not issubclass(ch.__class__, PreTrainedModel):\\n ch.apply(lambda module: self.transformer.__class__._init_weights(self.transformer, module))\",\n \"def init_params(module):\\n\\n if isinstance(module, torch.nn.Linear):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n if module.bias is not None:\\n module.bias.data.zero_()\\n if isinstance(module, torch.nn.Embedding):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n if module.padding_idx is not None:\\n module.weight.data[module.padding_idx].zero_()\",\n \"def initialize_weights(self):\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(\\n self._batch)\",\n \"def init_weights(self):\\n if isinstance(self.pretrained, str):\\n logger = get_root_logger()\\n logger.info(f'load model from: {self.pretrained}')\\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\\n elif self.pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n xavier_init(m, distribution='uniform')\\n elif isinstance(m, nn.Linear):\\n normal_init(m, std=0.01)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(model):\\n ...\",\n \"def initialize(self):\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):\\n nn.init.xavier_normal_(m.weight)\\n if m.bias is not None:\\n nn.init.constant_(m.bias, 0)\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1)\\n nn.init.constant_(m.bias, 0)\",\n \"def _init(module):\\n classname = module.__class__.__name__\\n if classname.find('Conv') != -1:\\n try:\\n nn.init.xavier_uniform_(module.weight.data)\\n module.bias.data.fill_(0) # May fail.\\n except AttributeError:\\n pass\",\n \"def init_weights(self):\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):\\n xavier_uniform_(m.weight)\\n if m.bias is not None:\\n zeros_(m.bias)\",\n \"def init_weights_(self):\\n raise NotImplementedError\",\n \"def _initialize_weights(self):\\n pass\",\n \"def _initialize_weights(self):\\r\\n for m in self.modules():\\r\\n if isinstance(m, nn.Conv2d):\\r\\n m.weight.data.normal_(0, 0.05)\\r\\n if m.bias is not None:\\r\\n m.bias.data.zero_()\",\n \"def setWeightInitializer(self,weights):\\n self.init_w = weights\",\n \"def init_weights(self, clz):\\n for ch in self.children():\\n if issubclass(ch.__class__, nn.Module) and not issubclass(ch.__class__, PreTrainedModel):\\n ch.apply(lambda module: clz._init_weights(self.lrm, module))\",\n \"def init_weights(self) -> None:\\n nn.init.kaiming_normal_(self._U)\\n nn.init.kaiming_normal_(self._W)\\n nn.init.kaiming_normal_(self._V)\\n\\n nn.init.normal_(self._b)\",\n \"def initialize_weights(self):\\n for layer in self._cnn_layers:\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(layer)\",\n \"def init_weights(module, negative_slope=0):\\n if isinstance(module, (nn.Conv2d, nn.ConvTranspose2d)):\\n nn.init.kaiming_normal_(module.weight.data, negative_slope)\\n module.bias.data.zero_()\",\n \"def weights_init(m):\\n if type(m) == torch.nn.Linear:\\n m.weight.data.normal_(0.0, 0.02)\\n m.bias.data.fill_(0)\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n kaiming_init(m)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n\\n if self.zero_init_residual:\\n for m in self.modules():\\n if isinstance(m, Bottleneck):\\n constant_init(m.norm3, 0)\\n elif isinstance(m, BasicBlock):\\n constant_init(m.norm2, 0)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\",\n \"def init_weights(module: nn.Module, gain: float = 1) -> None:\\n if isinstance(module, (nn.Linear, nn.Conv2d)):\\n nn.init.orthogonal_(module.weight, gain=gain)\\n if module.bias is not None:\\n module.bias.data.fill_(0.0)\",\n \"def init_weights(self):\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n xavier_init(m)\",\n \"def init_weights(self, load_weights=None):\\n if load_weights:\\n # TODO\\n pass\\n else:\\n # x: lower layer nodes n\\n # y: current layer nodes n\\n x = self.weights_shape[1]\\n y = self.weights_shape[0]\\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member\",\n \"def _initialize_weights(self, inputs):\\n if self.data_init:\\n self._data_dep_init(inputs)\\n else:\\n self._init_norm()\\n self._initialized = True\",\n \"def initialize_weights(self):\\n tf.nest.map_structure(\\n weights_initializer.WeightsInitializer.initialize_layer_or_model,\\n self._layer_nest)\",\n \"def init_weight(self):\\n init_layer(self.conv1)\\n init_layer(self.conv2)\\n init_bn(self.norm1)\\n init_bn(self.norm2)\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\\n # Tie weights if needed\\n self.tie_weights()\",\n \"def init_weights(net):\\n for m in net.modules():\\n if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):\\n nn.init.xavier_uniform_(m.weight)\\n # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\\n if m.bias is not None:\\n nn.init.constant_(m.bias, 0)\\n\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1)\\n nn.init.constant_(m.bias, 0)\\n\\n return net\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(m):\\n if isinstance(m, nn.Linear):\\n nn.init.normal_(m.weight, mean=0.1, std=0.01)\\n nn.init.constant_(m.bias, 0.0)\",\n \"def init_weights(m):\\n\\tif type(m) == nn.Linear:\\n\\t\\ttorch.nn.init.xavier_normal(m.weight)\\n\\t\\tm.bias.data.fill_(0.01)\",\n \"def init_weight(self):\\n init_bn(self.norm0)\",\n \"def init_weights(self, pretrained: Optional[str] = None) -> None:\\n if isinstance(pretrained, str):\\n logger = MMLogger.get_current_instance()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n kaiming_init(m)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n if self.zero_init_residual:\\n\\n for m in self.modules():\\n if isinstance(m, Bottleneck):\\n constant_init(m.norm3, 0)\\n elif isinstance(m, BasicBlock):\\n constant_init(m.norm2, 0)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def _reset_weights(m):\\n\\n nn = import_optional_dependency(\\\"torch.nn\\\")\\n init = import_optional_dependency(\\\"torch.nn.init\\\")\\n if isinstance(m, nn.Conv1d):\\n init.normal_(m.weight.data)\\n if m.bias is not None:\\n init.normal_(m.bias.data)\\n elif isinstance(m, nn.Conv2d):\\n init.xavier_normal_(m.weight.data)\\n if m.bias is not None:\\n init.normal_(m.bias.data)\\n elif isinstance(m, nn.Conv3d):\\n init.xavier_normal_(m.weight.data)\\n if m.bias is not None:\\n init.normal_(m.bias.data)\\n elif isinstance(m, nn.ConvTranspose1d):\\n init.normal_(m.weight.data)\\n if m.bias is not None:\\n init.normal_(m.bias.data)\\n elif isinstance(m, nn.ConvTranspose2d):\\n init.xavier_normal_(m.weight.data)\\n if m.bias is not None:\\n init.normal_(m.bias.data)\\n elif isinstance(m, nn.ConvTranspose3d):\\n init.xavier_normal_(m.weight.data)\\n if m.bias is not None:\\n init.normal_(m.bias.data)\\n elif isinstance(m, nn.BatchNorm1d):\\n init.normal_(m.weight.data, mean=1, std=0.02)\\n init.constant_(m.bias.data, 0)\\n elif isinstance(m, nn.BatchNorm2d):\\n init.normal_(m.weight.data, mean=1, std=0.02)\\n init.constant_(m.bias.data, 0)\\n elif isinstance(m, nn.BatchNorm3d):\\n init.normal_(m.weight.data, mean=1, std=0.02)\\n init.constant_(m.bias.data, 0)\\n elif isinstance(m, nn.Linear):\\n init.xavier_normal_(m.weight.data)\\n init.normal_(m.bias.data)\\n elif isinstance(m, nn.LSTM):\\n for param in m.parameters():\\n if len(param.shape) >= 2:\\n init.orthogonal_(param.data)\\n else:\\n init.normal_(param.data)\\n elif isinstance(m, nn.LSTMCell):\\n for param in m.parameters():\\n if len(param.shape) >= 2:\\n init.orthogonal_(param.data)\\n else:\\n init.normal_(param.data)\\n elif isinstance(m, nn.GRU):\\n for param in m.parameters():\\n if len(param.shape) >= 2:\\n init.orthogonal_(param.data)\\n else:\\n init.normal_(param.data)\\n elif isinstance(m, nn.GRUCell):\\n for param in m.parameters():\\n if len(param.shape) >= 2:\\n init.orthogonal_(param.data)\\n else:\\n init.normal_(param.data)\",\n \"def init_weights(self):\\n\\n params = torch.load(self.resnet_weight)\\n\\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\\n\\n\\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\\n self.fc3.out_features)\\n self.fc3.weight.data.uniform_(-r, r)\\n self.fc3.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\\n self.fc4.out_features)\\n self.fc4.weight.data.uniform_(-r, r)\\n self.fc4.bias.data.fill_(0)\",\n \"def init_weights(self):\\n self.transformer.init_weights()\\n if self.loss_cls.use_sigmoid:\\n bias_init = bias_init_with_prob(0.01)\\n for m in self.cls_branches:\\n nn.init.constant_(m[-1].bias, bias_init)\",\n \"def init_weights(self, pretrained=None):\\n if pretrained is not None:\\n self.pretrained = pretrained\\n self.backbone.init_weights(self.pretrained)\\n self.mesh_head.init_weights()\\n if self.with_gan:\\n self.discriminator.init_weights()\",\n \"def weight_initialization(m: nn.Module) -> None:\\n if type(m) == nn.Linear:\\n # nn.init.xavier_uniform_(m.weight, np.sqrt(2.)) # gain is sqrt(2) because we use ReLU\\n nn.init.kaiming_uniform_(m.weight, a=np.sqrt(5))\\n # nn.init.uniform(m.weight, 0., 0.)\",\n \"def init_weights(self):\\n self._q_neuron.h(self._weights) \\n self._q_neuron.x(self._weights)\",\n \"def init_weights(network):\\n for m in network.modules():\\n # normal convblock and skip convblock initialisation\\n if isinstance(m, (ConvBlock, ConvBlockSkip)):\\n if network.weights_init == 'normal':\\n torch.nn.init.normal_(m.conv1.weight)\\n torch.nn.init.normal_(m.conv2.weight)\\n elif network.weights_init == 'orthogonal':\\n torch.nn.init.orthogonal_(m.conv1.weight)\\n torch.nn.init.orthogonal_(m.conv2.weight)\\n elif network.weights_init == 'xavier_uniform':\\n torch.nn.init.xavier_uniform_(m.conv1.weight)\\n torch.nn.init.xavier_uniform_(m.conv2.weight)\\n elif network.weights_init == 'xavier_normal':\\n torch.nn.init.xavier_normal_(m.conv1.weight)\\n torch.nn.init.xavier_normal_(m.conv2.weight)\\n elif network.weights_init == 'kaiming_uniform':\\n torch.nn.init.kaiming_uniform_(m.conv1.weight)\\n torch.nn.init.kaiming_uniform_(m.conv2.weight)\\n elif network.weights_init == 'kaiming_normal':\\n torch.nn.init.kaiming_normal_(m.conv1.weight)\\n torch.nn.init.kaiming_normal_(m.conv2.weight)\\n m.conv1.bias.data.fill_(0.0)\\n m.conv2.bias.data.fill_(0.0)\\n # fixup block initialisation (see fixup paper for details)\\n elif isinstance(m, ConvBlockFixup):\\n nn.init.normal_(m.conv1.weight, mean=0, std=np.sqrt(\\n 2 / (m.conv1.weight.shape[0] * np.prod(m.conv1.weight.shape[2:]))) * network.nb_conv_blocks ** (-0.5))\\n nn.init.constant_(m.conv2.weight, 0)\\n # linear layers\\n elif isinstance(m, nn.Linear):\\n if network.use_fixup:\\n nn.init.constant_(m.weight, 0)\\n elif network.weights_init == 'normal':\\n torch.nn.init.normal_(m.weight)\\n elif network.weights_init == 'orthogonal':\\n torch.nn.init.orthogonal_(m.weight)\\n elif network.weights_init == 'xavier_uniform':\\n torch.nn.init.xavier_uniform_(m.weight)\\n elif network.weights_init == 'xavier_normal':\\n torch.nn.init.xavier_normal_(m.weight)\\n elif network.weights_init == 'kaiming_uniform':\\n torch.nn.init.kaiming_uniform_(m.weight)\\n elif network.weights_init == 'kaiming_normal':\\n torch.nn.init.kaiming_normal_(m.weight)\\n nn.init.constant_(m.bias, 0)\\n # LSTM initialisation\\n elif isinstance(m, nn.LSTM):\\n for name, param in m.named_parameters():\\n if 'weight_ih' in name:\\n if network.weights_init == 'normal':\\n torch.nn.init.normal_(param.data)\\n elif network.weights_init == 'orthogonal':\\n torch.nn.init.orthogonal_(param.data)\\n elif network.weights_init == 'xavier_uniform':\\n torch.nn.init.xavier_uniform_(param.data)\\n elif network.weights_init == 'xavier_normal':\\n torch.nn.init.xavier_normal_(param.data)\\n elif network.weights_init == 'kaiming_uniform':\\n torch.nn.init.kaiming_uniform_(param.data)\\n elif network.weights_init == 'kaiming_normal':\\n torch.nn.init.kaiming_normal_(param.data)\\n elif 'weight_hh' in name:\\n if network.weights_init == 'normal':\\n torch.nn.init.normal_(param.data)\\n elif network.weights_init == 'orthogonal':\\n torch.nn.init.orthogonal_(param.data)\\n elif network.weights_init == 'xavier_uniform':\\n torch.nn.init.xavier_uniform_(param.data)\\n elif network.weights_init == 'xavier_normal':\\n torch.nn.init.xavier_normal_(param.data)\\n elif network.weights_init == 'kaiming_uniform':\\n torch.nn.init.kaiming_uniform_(param.data)\\n elif network.weights_init == 'kaiming_normal':\\n torch.nn.init.kaiming_normal_(param.data)\\n elif 'bias' in name:\\n param.data.fill_(0.0)\\n return network\",\n \"def init_parameters(module: nn.Module):\\n for m in module.modules():\\n if isinstance(m, nn.Conv2d):\\n # todo: check if fan_out is valid\\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1)\\n nn.init.constant_(m.bias, 0)\",\n \"def weights_init(model):\\n classname = model.__class__.__name__\\n if classname.find('Conv') != -1:\\n nn.init.normal_(model.weight.data, 0.0, 0.02)\\n elif classname.find('BatchNorm') != -1:\\n nn.init.normal_(model.weight.data, 1.0, 0.02)\\n nn.init.constant_(model.bias.data, 0)\",\n \"def weights_init(self, m):\\n if isinstance(m, nn.Conv1d):\\n torch.nn.init.xavier_uniform(m.weight.data)\\n m.bias.data.fill_(0.0)\\n if isinstance(m, nn.LSTM):\\n torch.nn.init.xavier_uniform(m.weight_ih_l0)\\n torch.nn.init.orthogonal(m.weight_hh_l0)\\n for names in m._all_weights:\\n for name in filter(lambda n: \\\"bias\\\" in n, names):\\n bias = getattr(m, name)\\n n = bias.size(0)\\n start, end = n // 4, n // 2\\n bias.data[start:end].fill_(1.0)\\n m.bias_ih_l0.data.fill_(0.0)\",\n \"def initialize_weights(model: nn.Module, transformer: bool = False) -> None:\\n for param in model.parameters():\\n if param.dim() == 1:\\n if transformer:\\n nn.init.constant_(param, 0.01)\\n else:\\n nn.init.constant_(param, 0)\\n else:\\n nn.init.xavier_normal_(param)\",\n \"def initialize_weights(m):\\n if isinstance(m, nn.Linear) or isinstance(m, nn.ConvTranspose2d):\\n init.xavier_uniform(m.weight.data)\",\n \"def init_weights(self):\\n\\n super().init_weights()\\n\\n init_type = None if self.init_cfg is None else self.init_cfg.get(\\n 'type', None)\\n if init_type != 'Pretrained' and self.with_tsa:\\n for module in [\\n self.fusion.feat_fusion, self.fusion.spatial_attn1,\\n self.fusion.spatial_attn2, self.fusion.spatial_attn3,\\n self.fusion.spatial_attn4, self.fusion.spatial_attn_l1,\\n self.fusion.spatial_attn_l2, self.fusion.spatial_attn_l3,\\n self.fusion.spatial_attn_add1\\n ]:\\n kaiming_init(\\n module.conv,\\n a=0.1,\\n mode='fan_out',\\n nonlinearity='leaky_relu',\\n bias=0,\\n distribution='uniform')\",\n \"def weights_init(m):\\n if(type(m) == nn.ConvTranspose2d or type(m) == nn.Conv2d):\\n nn.init.normal_(m.weight.data, 0.0, 0.02)\\n elif(type(m) == nn.BatchNorm2d):\\n nn.init.normal_(m.weight.data, 1.0, 0.02)\\n nn.init.constant_(m.bias.data, 0)\",\n \"def weights_init(m):\\n if(type(m) == nn.ConvTranspose2d or type(m) == nn.Conv2d):\\n nn.init.normal_(m.weight.data, 0.0, 0.02)\\n elif(type(m) == nn.BatchNorm2d):\\n nn.init.normal_(m.weight.data, 1.0, 0.02)\\n nn.init.constant_(m.bias.data, 0)\",\n \"def init_weights(self):\\n \\n self.w = np.random.randn(self.D) / np.sqrt(self.D)\",\n \"def init_weights(self, init_w=3e-3):\\n self.l3.weight.data.uniform_(-init_w, init_w)\\n self.l3.bias.data.uniform_(-init_w, init_w)\",\n \"def init_weights(self, init_w=3e-3):\\n self.l3.weight.data.uniform_(-init_w, init_w)\\n self.l3.bias.data.uniform_(-init_w, init_w)\",\n \"def _init_weights(self):\\n nn.init.xavier_normal_(self.out.weight)\",\n \"def init_weights(m):\\n if isinstance(m, nn.Conv2d):\\n # Note that there is no bias due to BN\\n fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\\n m.weight.data.normal_(mean=0.0, std=np.sqrt(2.0 / fan_out))\\n elif isinstance(m, nn.BatchNorm2d):\\n zero_init_gamma = cfg.BN.ZERO_INIT_FINAL_GAMMA\\n zero_init_gamma = hasattr(m, \\\"final_bn\\\") and m.final_bn and zero_init_gamma\\n m.weight.data.fill_(0.0 if zero_init_gamma else 1.0)\\n m.bias.data.zero_()\\n elif isinstance(m, nn.Linear):\\n m.weight.data.normal_(mean=0.0, std=0.01)\\n m.bias.data.zero_()\",\n \"def init_weights(self, pretrained=None):\\n self.online_backbone.init_weights() # backbone\\n for online_neck in self.online_necks:\\n online_neck.init_weights(init_linear='kaiming') # projection\\n\\n for param_ol, param_tgt in zip(self.online_backbone.parameters(),\\n self.target_backbone.parameters()):\\n param_tgt.data.copy_(param_ol.data)\\n for param_ol, param_tgt in zip(self.online_necks.parameters(),\\n self.target_necks.parameters()):\\n param_tgt.data.copy_(param_ol.data)\\n # init the predictor in the head\\n for head in self.heads:\\n head.init_weights()\",\n \"def init_weights(m):\\n if isinstance(m, nn.Conv2d):\\n # Note that there is no bias due to BN\\n fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\\n m.weight.data.normal_(mean=0.0, std=math.sqrt(2.0 / fan_out))\\n elif isinstance(m, nn.BatchNorm2d):\\n zero_init_gamma = cfg.BN.ZERO_INIT_FINAL_GAMMA\\n zero_init_gamma = hasattr(m, \\\"final_bn\\\") and m.final_bn and zero_init_gamma\\n m.weight.data.fill_(0.0 if zero_init_gamma else 1.0)\\n m.bias.data.zero_()\\n elif isinstance(m, nn.Linear):\\n m.weight.data.normal_(mean=0.0, std=0.01)\\n m.bias.data.zero_()\",\n \"def init_weights(self, pretrained=None):\\n if pretrained is not None:\\n self.pretrained = pretrained\\n self.backbone.init_weights(self.pretrained)\\n if self.with_necks:\\n for neck in self.necks:\\n if hasattr(neck, 'init_weights'):\\n neck.init_weights()\\n for head in self.heads:\\n if hasattr(head, 'init_weights'):\\n head.init_weights()\",\n \"def initialize_NN(self, m):\\n\\n if type(m) == nn.Linear:\\n nn.init.xavier_uniform_(m.weight)\\n # print(m.weight)\",\n \"def initialize_weights(self, weights_initializer, bias_initializer):\\n wshapes = [\\n [self.input_size, self.hidden_size[0]],\\n [self.hidden_size[0], self.hidden_size[1]],\\n [self.hidden_size[1], self.output_size]\\n ]\\n\\n bshapes = [\\n [1, self.hidden_size[0]],\\n [1, self.hidden_size[1]],\\n [1, self.output_size]\\n ]\\n\\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\\n\\n self.trainable_variables = self.weights + self.biases\",\n \"def init_weights(self):\\r\\n constant_init(self.sampling_offsets, 0.)\\r\\n thetas = torch.arange(\\r\\n self.num_heads,\\r\\n dtype=torch.float32) * (2.0 * math.pi / self.num_heads)\\r\\n grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)\\r\\n grid_init = (grid_init /\\r\\n grid_init.abs().max(-1, keepdim=True)[0]).view(\\r\\n self.num_heads, 1, 1,\\r\\n 2).repeat(1, self.num_levels, self.num_points, 1)\\r\\n for i in range(self.num_points):\\r\\n grid_init[:, :, i, :] *= i + 1\\r\\n\\r\\n self.sampling_offsets.bias.data = grid_init.view(-1)\\r\\n constant_init(self.attention_weights, val=0., bias=0.)\\r\\n xavier_init(self.value_proj, distribution='uniform', bias=0.)\\r\\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\\r\\n self._is_init = True\",\n \"def init_weights(self, pretrained=None):\\n if pretrained is not None:\\n self.pretrained = pretrained\\n for modal in self.modality:\\n getattr(self.backbone, modal).init_weights(self.pretrained.get(modal, None))\\n if hasattr(self, 'neck'):\\n self.neck.init_weights()\\n if hasattr(self, 'cls_head'):\\n self.cls_head.init_weights()\",\n \"def init_weights(self, dims):\\n self.W = np.random.normal(size=dims) * 0.0001\",\n \"def __init__(self, z_dim, initailize_weights=True):\\n super().__init__()\\n self.z_dim = z_dim\\n\\n self.proprio_encoder = nn.Sequential(\\n nn.Linear(8, 32),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Linear(32, 64),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Linear(64, 128),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Linear(128, 2 * self.z_dim),\\n nn.LeakyReLU(0.1, inplace=True),\\n )\\n\\n if initailize_weights:\\n init_weights(self.modules())\",\n \"def __init__(self, weights):\\n self._weights = weights\",\n \"def init_bert_params(module):\\n\\n if isinstance(module, nn.Linear):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n if module.bias is not None:\\n module.bias.data.zero_()\\n if isinstance(module, nn.Embedding):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n if module.padding_idx is not None:\\n module.weight.data[module.padding_idx].zero_()\\n if isinstance(module, MultiheadAttention):\\n module.in_proj_weight.data.normal_(mean=0.0, std=0.02)\",\n \"def initialise_parameters(self):\\n # Weights\\n init = select_w_init(self.w_init)\\n if self.w_gain:\\n gain = nn.init.calculate_gain('relu')\\n init(self.relations, gain=gain)\\n else:\\n init(self.relations)\\n\\n # Biases\\n if self.b_init:\\n init = select_b_init(self.b_init)\\n init(self.sbias)\\n init(self.pbias)\\n init(self.obias)\",\n \"def init_weights(model, fc_init_std=0.01):\\n for m in model.modules():\\n if isinstance(m, nn.Conv3d):\\n \\\"\\\"\\\"\\n Follow the initialization method proposed in:\\n {He, Kaiming, et al.\\n \\\"Delving deep into rectifiers: Surpassing human-level\\n performance on imagenet classification.\\\"\\n arXiv preprint arXiv:1502.01852 (2015)}\\n \\\"\\\"\\\"\\n c2_msra_fill(m, nonlinearity=('relu', 'leaky_relu')[0])\\n # c2_xavier_fill(m)\\n # nn.init.xavier_normal_(m.weight)\\n # nn.init.xavier_uniform_(m.weight)\\n # if m.bias is not None: # pyre-ignore\\n # nn.init.constant_(m.bias, 0)\\n elif isinstance(m, nn.BatchNorm3d) or isinstance(m, nn.InstanceNorm3d):\\n m.weight.data.fill_(1.0)\\n m.bias.data.zero_()\\n if isinstance(m, nn.Linear): # This assumes nn.Linear is the final layers\\n # TODO check to see if this is effective in this architecture since the final is a conv3d\\n m.weight.data.normal_(mean=0.0, std=fc_init_std)\\n m.bias.data.zero_()\",\n \"def InitWeights(self):\\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\\n self.w0 = -1 + 2 * np.random.rand()\",\n \"def _set_weights(self):\\n self.Wc = torch.mm(self.TP.T, self.W).mm(self.TP)\",\n \"def weights_init(m):\\n if (\\n isinstance(m, nn.Linear)\\n or isinstance(m, nn.EmbeddingBag)\\n or isinstance(m, nn.Embedding)\\n or isinstance(m, SparseLinear)\\n ):\\n nn.init.xavier_normal_(m.weight)\",\n \"def _initialize_weights(self):\\n for _, cell in self.cells_and_names():\\n if isinstance(cell, nn.Conv2d):\\n cell.weight.set_data(orthogonal(cell.weight.shape, 0.6))\\n if cell.bias is not None:\\n cell.bias.set_data(\\n init.initializer(init.Constant(0.01), cell.bias.shape,\\n cell.bias.dtype))\",\n \"def init_weights2(net):\\n\\tfor m in net.modules():\\n\\t\\tif isinstance(m, nn.Conv2d):\\n\\t\\t\\tnn.init.xavier_uniform_(m.weight)\\n\\t\\t\\tif m.bias is not None:\\n\\t\\t\\t\\tnn.init.constant_(m.bias, 0)\\n\\t\\t\\t\\n\\t\\telif isinstance(m, nn.BatchNorm2d):\\n\\t\\t\\tnn.init.constant_(m.weight, 1)\\n\\t\\t\\tnn.init.constant_(m.bias, 0)\\n\\t\\t\\n\\t\\telif isinstance(m, nn.Linear):\\n\\t\\t\\tnn.init.xavier_uniform_(m.weight)\\n\\n\\t\\t\\tif m.bias is not None:\\n\\t\\t\\t\\tnn.init.constant_(m.bias, 0)\\n\\n\\treturn net\",\n \"def init_weights(net, init_gain=0.02):\\n def init_func(m): # define the initialization function\\n classname = m.__class__.__name__\\n if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):\\n init.normal_(m.weight.data, 0.0, init_gain)\\n if hasattr(m, 'bias') and m.bias is not None:\\n init.constant_(m.bias.data, 0.0)\\n\\n print('initialize network')\\n net.apply(init_func) # apply the initialization function <init_func>\",\n \"def initialize_weights(self, seed=None):\\r\\n if seed!=None:\\r\\n np.random.seed(seed)\\r\\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)\",\n \"def _init_modules(self, pretrained_weights=None):\\n if pretrained_weights is None:\\n if cfg.MODEL.LOAD_PRETRAINED_BACKBONE_WEIGHTS:\\n print(\\\"\\\\n-------------------------------------------\\\")\\n print(\\\"Load pre-trained ImageNet weights\\\")\\n print(\\\"\\\\n-------------------------------------------\\\")\\n weight_utils.load_caffe2_pretrained_weights(self, cfg.MODEL.PRETRAINED_BACKBONE_WEIGHTS)\\n return\\n\\n pretrained_detectron = torch.load(pretrained_weights)\\n\\n if cfg.RPN.RPN_ON:\\n load_layers = ['Conv_Body', 'RPN']\\n else:\\n load_layers = ['Conv_Body']\\n\\n mapping, _ = self.detectron_weight_mapping()\\n state_dict = {}\\n ckpt = pretrained_detectron['model']\\n for name in ckpt:\\n if name.split('.')[0] in load_layers:\\n if mapping[name]:\\n state_dict[name] = ckpt[name]\\n self.load_state_dict(state_dict, strict=False)\\n del pretrained_detectron\\n torch.cuda.empty_cache()\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\r\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\r\\n self.fc.bias.data.fill_(0)\\r\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def initialize_weights(self, seed=None):\\n if seed != None:\\n np.random.seed(seed)\\n self.weights = np.random.randn(self.number_of_nodes, self.input_dimensions)\",\n \"def init_model(self, model_init):\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n if model_init == 'he_fout':\\n n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\\n m.weight.data.normal_(0, math.sqrt(2.0 / n))\\n elif model_init == 'he_fin':\\n n = m.kernel_size[0] * m.kernel_size[1] * m.in_channels\\n m.weight.data.normal_(0, math.sqrt(2.0 / n))\\n else:\\n raise NotImplementedError\\n if m.bias is not None:\\n m.bias.data.zero_()\\n elif isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.BatchNorm1d):\\n m.weight.data.fill_(1)\\n m.bias.data.zero_()\\n elif isinstance(m, nn.Linear):\\n stdv = 1.0 / math.sqrt(m.weight.size(1))\\n m.weight.data.uniform_(-stdv, stdv)\\n if m.bias is not None:\\n m.bias.data.zero_()\",\n \"def __init__(self, num_parameters=1, init=0.25):\\n super(PReLU, self).__init__()\\n self.num_parameters = num_parameters\\n self.weight = Parameter(Tensor(num_parameters).fill_(init))\",\n \"def initWeights(self):\\n self.weights = []\\n self.bias = []\\n for i, dim in enumerate(self.dimensions[1:]):\\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\\n self.bias.append(np.random.uniform(-1,1,dim))\",\n \"def init_weights(self, pretrained=None):\\n\\n super(EncoderDecoder_gan, self).init_weights(pretrained)\\n self.backbone.init_weights(pretrained=pretrained)\\n self.backbone_gan.init_weights(pretrained=pretrained)\\n self.decode_head.init_weights()\\n # init GAN\\n # self.discriminator.init_weight()\\n # self.G_head.init_weights()\\n if self.with_auxiliary_head:\\n if isinstance(self.auxiliary_head, nn.ModuleList):\\n for aux_head in self.auxiliary_head:\\n aux_head.init_weights()\\n else:\\n self.auxiliary_head.init_weights()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77734","0.7753587","0.76126516","0.76039255","0.75937414","0.7557966","0.75483835","0.75483835","0.75483835","0.7541337","0.75397253","0.7527526","0.74981326","0.7479258","0.7456155","0.74487233","0.74385613","0.74289656","0.74223495","0.74188006","0.7390666","0.7355017","0.7322928","0.73041874","0.7290801","0.725247","0.7250708","0.7203141","0.71963996","0.718846","0.71807146","0.7161181","0.71259385","0.71217954","0.71107715","0.70876","0.7076905","0.70622504","0.70560426","0.70481575","0.70409447","0.70243335","0.70156145","0.69991356","0.69991356","0.69991356","0.69991356","0.69818896","0.6961957","0.69595605","0.6943721","0.6929089","0.6927725","0.6908174","0.689139","0.688329","0.68746215","0.6872657","0.68484735","0.6821757","0.6798332","0.6789858","0.6719415","0.6713503","0.66906285","0.66906285","0.6664038","0.66605675","0.66605675","0.66525155","0.6652108","0.6633657","0.663193","0.662998","0.66137195","0.6600654","0.65849996","0.6577606","0.6558788","0.65549135","0.65521544","0.65400124","0.6528775","0.6524785","0.6498938","0.64972377","0.6496245","0.64940524","0.6488828","0.64747876","0.6463073","0.6456957","0.64418703","0.64418703","0.64418703","0.6437399","0.64202416","0.6416855","0.64064837","0.64038074","0.6401574"],"string":"[\n \"0.77734\",\n \"0.7753587\",\n \"0.76126516\",\n \"0.76039255\",\n \"0.75937414\",\n \"0.7557966\",\n \"0.75483835\",\n \"0.75483835\",\n \"0.75483835\",\n \"0.7541337\",\n \"0.75397253\",\n \"0.7527526\",\n \"0.74981326\",\n \"0.7479258\",\n \"0.7456155\",\n \"0.74487233\",\n \"0.74385613\",\n \"0.74289656\",\n \"0.74223495\",\n \"0.74188006\",\n \"0.7390666\",\n \"0.7355017\",\n \"0.7322928\",\n \"0.73041874\",\n \"0.7290801\",\n \"0.725247\",\n \"0.7250708\",\n \"0.7203141\",\n \"0.71963996\",\n \"0.718846\",\n \"0.71807146\",\n \"0.7161181\",\n \"0.71259385\",\n \"0.71217954\",\n \"0.71107715\",\n \"0.70876\",\n \"0.7076905\",\n \"0.70622504\",\n \"0.70560426\",\n \"0.70481575\",\n \"0.70409447\",\n \"0.70243335\",\n \"0.70156145\",\n \"0.69991356\",\n \"0.69991356\",\n \"0.69991356\",\n \"0.69991356\",\n \"0.69818896\",\n \"0.6961957\",\n \"0.69595605\",\n \"0.6943721\",\n \"0.6929089\",\n \"0.6927725\",\n \"0.6908174\",\n \"0.689139\",\n \"0.688329\",\n \"0.68746215\",\n \"0.6872657\",\n \"0.68484735\",\n \"0.6821757\",\n \"0.6798332\",\n \"0.6789858\",\n \"0.6719415\",\n \"0.6713503\",\n \"0.66906285\",\n \"0.66906285\",\n \"0.6664038\",\n \"0.66605675\",\n \"0.66605675\",\n \"0.66525155\",\n \"0.6652108\",\n \"0.6633657\",\n \"0.663193\",\n \"0.662998\",\n \"0.66137195\",\n \"0.6600654\",\n \"0.65849996\",\n \"0.6577606\",\n \"0.6558788\",\n \"0.65549135\",\n \"0.65521544\",\n \"0.65400124\",\n \"0.6528775\",\n \"0.6524785\",\n \"0.6498938\",\n \"0.64972377\",\n \"0.6496245\",\n \"0.64940524\",\n \"0.6488828\",\n \"0.64747876\",\n \"0.6463073\",\n \"0.6456957\",\n \"0.64418703\",\n \"0.64418703\",\n \"0.64418703\",\n \"0.6437399\",\n \"0.64202416\",\n \"0.6416855\",\n \"0.64064837\",\n \"0.64038074\",\n \"0.6401574\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":4484,"cells":{"query":{"kind":"string","value":"Generates a human readable summary of the present segmentation model, writes it to logging.info, and stores the ModelSummary object inside the argument `model`."},"document":{"kind":"string","value":"def summary_for_segmentation_models(config: ModelConfigBase, model: DeviceAwareModule) -> None:\n assert isinstance(model, BaseModel)\n crop_size = config.crop_size\n if isinstance(crop_size, int):\n crop_size = (crop_size, crop_size, crop_size)\n try:\n model.generate_model_summary(crop_size, log_summaries_to_files=config.log_summaries_to_files)\n except AttributeError as e:\n logging.warning(f\"summary_for_segmentation_models failed with exception {e}\")"},"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 generate_and_print_model_summary(config: ModelConfigBase, model: DeviceAwareModule) -> None:\n random_state = RandomStateSnapshot.snapshot_random_state()\n # There appears to be a bug in apex, where previous use (in training for example) causes problems\n # when another model is later built on the CPU (for example, before loading from a checkpoint)\n # https://github.com/NVIDIA/apex/issues/694\n # Hence, move the model to the GPU before doing model summary.\n if config.use_gpu:\n model = model.cuda()\n if isinstance(config, ScalarModelBase):\n # To generate the model summary, read the first item of the dataset. Then use the model's own\n # get_model_input function to convert the dataset item to input tensors, and feed them through the model.\n train_dataset = config.get_torch_dataset_for_inference(ModelExecutionMode.TRAIN)\n train_item_0 = next(iter(train_dataset.as_data_loader(shuffle=False, batch_size=1, num_dataload_workers=0)))\n model_inputs = get_scalar_model_inputs_and_labels(config, model, train_item_0).model_inputs\n # The model inputs may already be converted to float16, assuming that we would do mixed precision.\n # However, the model is not yet converted to float16 when this function is called, hence convert back to float32\n summary = ModelSummary(model)\n summary.generate_summary(input_tensors=model_inputs, log_summaries_to_files=config.log_summaries_to_files)\n elif config.is_segmentation_model:\n summary_for_segmentation_models(config, model)\n assert model.summarizer\n summary = model.summarizer # type: ignore\n else:\n raise ValueError(\"Don't know how to generate a summary for this type of model?\")\n RUN_CONTEXT.log(LoggingColumns.NumTrainableParameters, summary.n_trainable_params)\n random_state.restore_random_state()","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 summary(self):\n\n self.model.summary(print_fn=lambda x: logging.info(x))","def model_summary_to_file(model, save_path):\n with open(save_path, 'w') as fh:\n model.summary(print_fn=lambda x: fh.write(x + \"\\n\"))","def save_summary(model, model_name, stage_no):\n stringlist = []\n model.summary(print_fn=lambda x: stringlist.append(x))\n short_model_summary = \"\\n\".join(stringlist)\n \n with open(eval_path+\"{}_model_summary_stage_{}.txt\".format(model_name, stage_no), \"w\") as text_file:\n print(short_model_summary, file=text_file)","def print_summary(self):\n self.model.summary()","def show_model_summary(self):\n\t\treturn self.model.summary()","def summarize_model(\n model: keras.Model, fig_dir: Union[str, None] = None\n) -> None:\n\n submodels = []\n for layer in model.layers:\n if isinstance(layer, TimeDistributed):\n submodels.append(layer.layer)\n\n for submodel in submodels:\n submodel.summary()\n model.summary()\n\n if fig_dir is not None:\n for submodel in submodels:\n keras.utils.plot_model(\n submodel, os.path.join(fig_dir, f'model_{submodel.name}.png'),\n dpi=300\n )\n keras.utils.plot_model(\n model, os.path.join(fig_dir, 'model_full.png'), dpi=300\n )","def model_stats(opt, epoch, model):\n log = rlog.getLogger(opt.experiment + \".model\")\n if hasattr(opt, \"log\") and opt.log.detailed:\n # log histogram also\n assert isinstance(\n model, SVIModel\n ), \"This stat only makes sense for SVI models.\"\n for mu, std in zip(model.mu(), model.std()):\n log.put(mu=mu, std=std)\n log.trace(step=epoch, **model.summarize())\n log.reset()","def summary(self) -> None:\n print(\"Model manager summary:\")\n print(\"Preprocessor:\")\n print(self.preprocessor)\n print(\"Model summary:\")\n self.model.summary()\n print(\"Postprocessor:\")\n print(self.postprocessor)","def test_summaries(self):\n try:\n ans = str(self.model)\n except:\n assert False, \"Model __repr__ failed.\"\n\n try:\n print(self.model)\n except:\n assert False, \"Model print failed.\"\n\n try:\n self.model.summary()\n except:\n assert False, \"Model summary failed.\"","def _save_model_info(self, model):\r\n with open_(self.output_path / \"model.info\", \"w+\") as f:\r\n f.write(model.info)","def print_summary(self):\n print(\"Word Level\")\n self.model_word.summary()\n \n print(\"Sent Level\")\n self.model_sent.summary()\n\n print(\"Doc Level\")\n self.model.summary()","def test_get_summary_with_model(self):\n\t\t\n\t\tdescription = self.watcher.describe(model=self.model)\n\t\tself.assertEqual(11, len(description))\n\t\t\n\t\t\n\t\tdetails = self.watcher.analyze(model=self.model, layers=[self.second_layer])\n\t\treturned_summary = self.watcher.get_summary(details)\n\t\t\n\t\tprint(returned_summary)\n\t\t\n\t\tsaved_summary = self.watcher.get_summary()\n\t\tself.assertEqual(returned_summary, saved_summary)","def summary(self):\r\n print(self.model.summary())","def summary(self):\n print(self.model.summary())","def output_summary(self, v, vhat, sk, logged_matrics, train_dataset_label, val_dataset_label, summary_folder_path):\n\n mse = np.sum((v-vhat)**2)/len(v)\n train_loss = logged_matrics[\"train_loss\"]\n\n k = np.sum(p.numel() for p in self.parameters())\n\n numOfSamples = len(sk)\n aic = 2*k + numOfSamples*np.log(mse) + numOfSamples*(1+np.log(2*np.pi))\n\n summary_file = os.path.join(summary_folder_path, \"model_summary.txt\")\n if not os.path.isfile(summary_file):\n print(\"Created file \"+summary_file)\n with open(summary_file, \"w\") as output:\n output.write(\n \"Model Train_dataset_label Val_dataset_label Train_loss Test_loss AIC\\n\")\n else:\n print(summary_file +\n \" exists, model summary will be attached to the end of this file.\")\n\n with open(summary_file, \"a\") as output:\n model_name = self.version\n output.write(model_name + \" \" + train_dataset_label + \" \" +\n val_dataset_label + \" %f %f %f\\n\" % (train_loss, mse, aic))\n\n\n plt.scatter(sk, v, c=\"blue\", s=2, label=\"true\")\n plt.scatter(sk, vhat, c=\"red\", s=2, label=\"predict\")\n plt.legend()\n plt.xlabel(\"sk\")\n plt.ylabel(\"v\")\n\n plt.savefig(os.path.join(summary_folder_path, \"plots\", model_name+\".png\"))\n plt.show()\n\n np.savetxt(os.path.join(summary_folder_path, \"model_prediction\", model_name+\"_prediction.txt\"), np.column_stack((sk, v, vhat)), header=\"sk v vhat\", fmt='%.8f')\n\n\n print(\"Plot saved as\", os.path.join(summary_folder_path, \"plots\", model_name+\".png\"))\n print(\"Model prediction saved as\", os.path.join(summary_folder_path, \"model_prediction\", model_name+\"_prediction.txt\"))","def log_model_analysis(\n logger, image, segmentation_image, model, indices_to_colors_map, void_color, colors_to_ignore):\n\n ground_truth_overlay_image = net.utilities.get_segmentation_overlaid_image(\n image, segmentation_image, colors_to_ignore)\n\n predicted_segmentation_cube = model.predict(image)\n\n predicted_segmentation_image = net.data.get_segmentation_image(\n predicted_segmentation_cube, indices_to_colors_map, void_color)\n\n predicted_overlay_image = net.utilities.get_segmentation_overlaid_image(\n image, predicted_segmentation_image, colors_to_ignore)\n\n logger.info(vlogging.VisualRecord(\n \"Data\", [image, segmentation_image, predicted_segmentation_image,\n ground_truth_overlay_image, predicted_overlay_image]))","def summary(self):\n self.model.summary()","def review_model(model): \n \n diagnose_model(model)\n \n plot_param_coef(model)\n \n plot_p_values(model)\n \n return","def lme_summary(output_dir: str, model: LMEModel, tree: TreeNode) -> None:\n warnings.warn(\"This visualization are deprecated.\", DeprecationWarning)\n # log likelihood\n loglike = pd.Series({r.model.endog_names: r.model.loglike(r.params)\n for r in model.results})\n w, h = 500, 300 # plot width and height\n # Summary object\n smry = model.summary()\n\n t = _decorate_tree(tree, -loglike)\n\n p1 = radialplot(t, figsize=(800, 800))\n p1.title.text = 'Loglikelihood of submodels'\n p1.title_location = 'above'\n p1.title.align = 'center'\n p1.title.text_font_size = '18pt'\n\n # 2D scatter plot for prediction on PB\n p2 = _projected_prediction(model, plot_width=w, plot_height=h)\n p3 = _projected_residuals(model, plot_width=w, plot_height=h)\n hm_p = _heatmap_summary(model.pvalues.T, model.coefficients().T,\n plot_width=900, plot_height=400)\n\n # combine the cross validation, explained sum of squares tree and\n # residual plots into a single plot\n p = row(column(p2, p3), p1)\n p = column(hm_p, p)\n\n # Deposit all regression results\n _deposit_results(model, output_dir)\n\n index_fp = os.path.join(output_dir, 'index.html')\n with open(index_fp, 'w') as index_f:\n index_f.write('<html><body>\\n')\n index_f.write('<h1>Simplicial Linear Mixed Effects Summary</h1>\\n')\n index_f.write(smry.as_html())\n index_f.write(\n ('<th>Coefficients</th>\\n'\n '<a href=\"coefficients.csv\">'\n 'Download as CSV</a><br>\\n'\n '<th>Coefficient pvalues</th>\\n'\n '<a href=\"pvalues.csv\">'\n 'Download as CSV</a><br>\\n'\n '<th>FDR corrected coefficient pvalues</th>\\n'\n '<a href=\"fdr-corrected-pvalues.csv\">'\n 'Download as CSV</a><br>\\n'\n '<th>Predicted Balances</th>\\n'\n '<a href=\"predicted.csv\">'\n 'Download as CSV</a><br>\\n'\n '<th>Residuals</th>\\n'\n '<a href=\"residuals.csv\">'\n 'Download as CSV</a><br>\\n')\n )\n\n diag_html = file_html(p, CDN, 'Diagnostic plots')\n index_f.write(diag_html)\n index_f.write('</body></html>\\n')","def print_summary(self, print_level = 0):\n\n print(\"==========================\")\n print(\"= FUNtoFEM model summary =\")\n print(\"==========================\")\n print(\"Model name:\", self.name)\n print(\"Number of bodies:\", len(self.bodies))\n print(\"Number of scenarios:\", len(self.scenarios))\n print(\" \")\n print(\"------------------\")\n print(\"| Bodies summary |\")\n print(\"------------------\")\n for body in self.bodies:\n print(\"Body:\", body.id, body.name)\n print(\" coupling group:\", body.group)\n print(\" transfer scheme:\", type(body.transfer))\n print(\" shape parameteration:\", type(body.shape))\n for vartype in body.variables:\n print(' variable type:', vartype)\n print(' number of ', vartype, ' variables:', len(body.variables[vartype]))\n if print_level >= 0:\n for var in body.variables[vartype]:\n print(' variable:', var.name, ', active?', var.active,', coupled?', var.coupled)\n print(' value and bounds:', var.value, var.lower, var.upper)\n\n print(\" \")\n print(\"--------------------\")\n print(\"| Scenario summary |\")\n print(\"--------------------\")\n for scenario in self.scenarios:\n print(\"scenario:\", scenario.id, scenario.name)\n print(\" coupling group:\", scenario.group)\n print(\" steps:\", scenario.steps)\n print(\" steady?:\", scenario.steady)\n for func in scenario.functions:\n print(' function:', func.name, ', analysis_type:', func.analysis_type)\n print(' adjoint?', func.adjoint)\n if not scenario.steady:\n print(' time range', func.start, ',', func.stop)\n print(' averaging', func.averaging)\n\n\n for vartype in scenario.variables:\n print(' variable type:', vartype)\n print(' number of ', vartype, ' variables:', len(scenario.variables[vartype]))\n if print_level >= 0:\n for var in scenario.variables[vartype]:\n print(' variable:', var.id, var.name, ', active?', var.active,', coupled?', var.coupled)\n print(' value and bounds:', var.value, var.lower, var.upper)","def model_architecture(self, filename=None):\n list_summary = []\n self.model.summary(print_fn=lambda x: list_summary.append(x))\n summary = \"\\n\".join(list_summary)\n\n if filename:\n with open(filename + '.txt', 'w') as f:\n f.write(summary)\n\n from keras.utils import plot_model\n plot_model(self.model, filename + '.jpg')\n\n return summary","def summary(self):\n from statsmodels.iolib.summary import Summary\n from statsmodels.iolib.table import SimpleTable\n model = self.model\n title = model.__class__.__name__ + ' Model Results'\n\n dep_variable = 'endog'\n if isinstance(self.model.endog, pd.DataFrame):\n dep_variable = self.model.endog.columns[0]\n elif isinstance(self.model.endog, pd.Series):\n dep_variable = self.model.endog.name\n seasonal_periods = None if self.model.seasonal is None else self.model.seasonal_periods\n lookup = {'add': 'Additive', 'additive': 'Additive',\n 'mul': 'Multiplicative', 'multiplicative': 'Multiplicative', None: 'None'}\n transform = self.params['use_boxcox']\n box_cox_transform = True if transform else False\n box_cox_coeff = transform if isinstance(transform, str) else self.params['lamda']\n if isinstance(box_cox_coeff, float):\n box_cox_coeff = '{:>10.5f}'.format(box_cox_coeff)\n top_left = [('Dep. Variable:', [dep_variable]),\n ('Model:', [model.__class__.__name__]),\n ('Optimized:', [str(np.any(self.optimized))]),\n ('Trend:', [lookup[self.model.trend]]),\n ('Seasonal:', [lookup[self.model.seasonal]]),\n ('Seasonal Periods:', [str(seasonal_periods)]),\n ('Box-Cox:', [str(box_cox_transform)]),\n ('Box-Cox Coeff.:', [str(box_cox_coeff)])]\n\n top_right = [\n ('No. Observations:', [str(len(self.model.endog))]),\n ('SSE', ['{:5.3f}'.format(self.sse)]),\n ('AIC', ['{:5.3f}'.format(self.aic)]),\n ('BIC', ['{:5.3f}'.format(self.bic)]),\n ('AICC', ['{:5.3f}'.format(self.aicc)]),\n ('Date:', None),\n ('Time:', None)]\n\n smry = Summary()\n smry.add_table_2cols(self, gleft=top_left, gright=top_right,\n title=title)\n formatted = self.params_formatted # type: pd.DataFrame\n\n def _fmt(x):\n abs_x = np.abs(x)\n scale = 1\n if abs_x != 0:\n scale = int(np.log10(abs_x))\n if scale > 4 or scale < -3:\n return '{:>20.5g}'.format(x)\n dec = min(7 - scale, 7)\n fmt = '{{:>20.{0}f}}'.format(dec)\n return fmt.format(x)\n\n tab = []\n for _, vals in formatted.iterrows():\n tab.append([_fmt(vals.iloc[1]),\n '{0:>20}'.format(vals.iloc[0]),\n '{0:>20}'.format(str(bool(vals.iloc[2])))])\n params_table = SimpleTable(tab, headers=['coeff', 'code', 'optimized'],\n title=\"\",\n stubs=list(formatted.index))\n\n smry.tables.append(params_table)\n\n return smry","def create_summary_and_adjust_model_for_gpus(self) -> None:\n if self._model is None:\n raise ValueError(\"Model must be created before it can be adjusted.\")\n\n if self.config.is_segmentation_model:\n summary_for_segmentation_models(self.config, self._model)\n # Prepare for mixed precision training and data parallelization (no-op if already done).\n # This relies on the information generated in the model summary.\n self.adjust_model_for_gpus()","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 set_up_summary_writer(model_config,\n sess):\n\n paths_config = model_config.paths_config\n\n logdir = paths_config.logdir\n if not os.path.exists(logdir):\n os.makedirs(logdir)\n\n logdir = logdir + '/eval'\n\n datetime_str = str(datetime.datetime.now())\n summary_writer = tf.summary.FileWriter(logdir + '/' + datetime_str,\n sess.graph)\n\n global_summaries = set([])\n summaries = set(tf.get_collection(tf.GraphKeys.SUMMARIES))\n summary_merged = summary_utils.summaries_to_keep(summaries,\n global_summaries,\n histograms=False,\n input_imgs=False,\n input_bevs=False)\n\n return summary_writer, summary_merged","def create_summary_writer(model, data_loader, log_dir):\n writer = SummaryWriter(log_dir=log_dir)\n data_loader_iter = iter(data_loader)\n x = next(data_loader_iter)\n try:\n writer.add_graph(model, x)\n except Exception as e:\n warnings.warn(\"Failed to save model graph: {}\".format(e))\n return writer","def get_model_summary(self):\n\n summary = self._model[0].get_model_summary()\n lower_bound = self._FLOAT_STRING_FORMAT.format(self._break_points[0])\n upper_bound = self._FLOAT_STRING_FORMAT.format(self._break_points[1])\n summary_title = 'Segment model range: ' \\\n + lower_bound \\\n + ' <= ' + self._explanatory_variables[0] \\\n + ' < ' + upper_bound\n summary.tables[0].title = summary_title\n\n number_of_segments = self.get_number_of_segments()\n\n spacer_table = SimpleTable(data=['=' * 50])\n\n for i in range(1, number_of_segments):\n segment_model_summary = self._model[i].get_model_summary()\n lower_bound = self._FLOAT_STRING_FORMAT.format(self._break_points[i])\n upper_bound = self._FLOAT_STRING_FORMAT.format(self._break_points[i + 1])\n summary_title = 'Segment model range: ' \\\n + lower_bound \\\n + ' <= ' + self._explanatory_variables[0] \\\n + ' < ' + upper_bound\n segment_model_summary.tables[0].title = summary_title\n summary.tables.extend([spacer_table] + segment_model_summary.tables)\n\n return summary","def get_model_summary(self):\n\n summary = Summary()\n\n # add the model equation with estimated parameters\n model_equation = self._get_model_equation()\n summary.tables.append(model_equation)\n\n # add the parameter summary\n params_summary = self._get_params_summary()\n summary.tables.append(params_summary)\n\n res = self._model.fit()\n\n # add more summary statistics\n gleft = self._get_left_summary_table(res)\n gright = self._get_right_summary_table(res)\n summary.add_table_2cols(res, gleft=gleft, gright=gright)\n\n # add extreme influence and outlier table\n high_leverage = ('High leverage:', self._FLOAT_STRING_FORMAT.format(3 * res.params.shape[0] / res.nobs))\n extreme_outlier = ('Extreme outlier (Standardized residual):', self._FLOAT_STRING_FORMAT.format(3))\n dfn = res.params.shape[0] + 1\n dfd = res.nobs + res.params.shape[0]\n high_influence_cooksd = (\"High influence (Cook's D)\",\n self._FLOAT_STRING_FORMAT.format(stats.f.ppf(0.9, dfn=dfn, dfd=dfd)))\n high_influence_dffits = (\"High influence (DFFITS)\",\n self._FLOAT_STRING_FORMAT.format(2 * np.sqrt(res.params.shape[0] / res.nobs)))\n influence_and_outlier_table_data = [high_leverage,\n extreme_outlier,\n high_influence_cooksd,\n high_influence_dffits]\n influence_and_outlier_table = SimpleTable(data=influence_and_outlier_table_data)\n summary.tables.append(influence_and_outlier_table)\n\n return summary","def model(self):\n\n # write summaries\n\n i = keras.Input(self.s)\n\n\n return keras.Model(inputs=[i], outputs=self.call(i))","def model(self):\n\n # write summaries\n\n i = keras.Input(self.s)\n\n\n return keras.Model(inputs=[i], outputs=self.call(i))","def summarize(self, *args, **kwargs) -> Optional[ModelSummary]:\n summary = super().summarize(*args, **kwargs)\n save_txt(summary, \"./network\")\n return summary","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 logging_init(model, graph):\n # Add ops to record summaries for loss and accuracy...\n train_loss = tf.summary.scalar(\"train_loss\", model.loss)\n train_accuracy = tf.summary.scalar(\"train_accuracy\", model.accuracy)\n # ...then merge these ops into one single op so that they easily be run\n # together\n train_summary_ops = tf.summary.merge([train_loss, train_accuracy])\n # Same ops, but with different names, so that train/test results show up\n # separately in TensorBoard\n test_loss = tf.summary.scalar(\"test_loss\", model.loss)\n test_accuracy = tf.summary.scalar(\"test_accuracy\", model.accuracy)\n test_summary_ops = tf.summary.merge([test_loss, test_accuracy])\n\n timestamp = int(time.time())\n run_log_dir = os.path.join(LOGS_DIR, str(timestamp))\n os.makedirs(run_log_dir)\n # (this step also writes the graph to the events file so that\n # it shows up in TensorBoard)\n summary_writer = tf.summary.FileWriter(run_log_dir, graph)\n\n return train_summary_ops, test_summary_ops, summary_writer","def summary(self):\n return self.model.summary()","def visualize_model(self):\n if self.model is None:\n print(\"%s.visualize: implement me\" % (self.__class__.__name__))","def save(model, save_name):\n dirs = configparser.ConfigParser()\n dirs.read(\"config/dir_config.ini\")\n\n save_name = os.path.splitext(save_name)[0]\n path = os.path.join(dirs[\"save_dirs\"][\"models\"], save_name + \".h5\")\n info = os.path.join(dirs[\"save_dirs\"][\"models\"], save_name + \"_info.txt\")\n\n with open(info, \"w\") as file:\n model.summary(print_fn=lambda x: file.write(f\"{x}\\n\"))\n model.save(path, overwrite=False)","def print_model_status(model):\n\tstatus = model.status\n\tif status == 2:\n\t\tgrb_message = 'Model solved to optimality'\n\tif status == 8:\n\t\tgrb_message = 'Model hits node limit'\n\tif status == 9:\n\t\tgrb_message = 'Model hits time limit'\n\ttry:\n\t\tprint grb_message\n\texcept NameError:\n\t\tprint 'unknown model exist status code: {}'.format(status)","def save_model(model, save_folder_path, model_name, model_ext):\n\n \n assert model_ext in [\".h5\", \".hdf5\"]\n assert os.path.isdir(save_folder_path)==True, \"model_folder_path is not a folder.\"\n\n print(\"[INFO] Saving model to {0}/\".format(save_folder_path))\n model_path = \"{}/{}\".format(save_folder_path, model_name + model_ext)\n model.save(model_path)\n\n with open('{}/{}'.format(save_folder_path, \"model_summary.txt\"), 'w') as f:\n with redirect_stdout(f):\n model.summary()\n \n # visualize model architecture\n plot_model(model, to_file=\"{}/{}.png\".format(save_folder_path, model_name),\n show_shapes=True)","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_model_generation(model):\n print('g1 = {} MW'.format(model.g[1].value))\n print('g2 = {} MW'.format(model.g[2].value))","def torch_summarize(model, show_weights=True, show_parameters=True):\n tmpstr = model.__class__.__name__ + ' (\\n'\n for key, module in model._modules.items():\n # if it contains layers let call it recursively to get params and weights\n if type(module) in [\n torch.nn.modules.container.Container,\n torch.nn.modules.container.Sequential\n ]:\n modstr = torch_summarize(module)\n else:\n modstr = module.__repr__()\n modstr = _addindent(modstr, 2)\n\n params = sum([np.prod(p.size()) for p in module.parameters()])\n weights = tuple([tuple(p.size()) for p in module.parameters()])\n\n tmpstr += ' (' + key + '): ' + modstr \n if show_weights:\n tmpstr += ', weights={}'.format(weights)\n if show_parameters:\n tmpstr += ', parameters={}'.format(params)\n tmpstr += '\\n' \n\n tmpstr = tmpstr + ')'\n return tmpstr","def get_summary(self):\n return self.model.summary()","def test_get_summary_with_new_model(self):\n\t\t\n\t\tnew_model = models.vgg13(weights='VGG13_Weights.IMAGENET1K_V1').state_dict()\n\t\tdescription = self.watcher.describe(model=new_model)\n\t\tself.assertEqual(13, len(description))\n\t\t\n\t\tfc3_layer = description.layer_id.to_numpy()[-1]\n\t\tdetails = self.watcher.analyze(model=new_model, layers=fc3_layer)\n\t\treturned_summary = self.watcher.get_summary(details)\n\t\t\n\t\tprint(returned_summary)\n\t\t\n\t\tsaved_summary = self.watcher.get_summary()\n\t\tself.assertEqual(returned_summary, saved_summary)","def torch_summarize(model, show_weights=True, show_parameters=True):\n\n tmpstr = model.__class__.__name__ + ' (\\n'\n for key, module in model._modules.items():\n # if it contains layers let call it recursively to get params and\n # weights\n if type(module) in [\n torch.nn.modules.container.Container,\n torch.nn.modules.container.Sequential\n ]:\n modstr = torch_summarize(module)\n else:\n modstr = module.__repr__()\n modstr = _addindent(modstr, 2)\n\n params = sum([np.prod(p.size()) for p in module.parameters()])\n weights = tuple([tuple(p.size()) for p in module.parameters()])\n\n tmpstr += ' (' + key + '): ' + modstr\n if show_weights:\n tmpstr += ', weights={}'.format(weights)\n if show_parameters:\n tmpstr += ', parameters={}'.format(params)\n tmpstr += '\\n'\n\n tmpstr = tmpstr + ')'\n return tmpstr","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 produce_summary_pdf(model_name, img_path, hyperparams, model_arch, train_stats):\n # datetime object containing current date and time\n now = datetime.now()\n dt_string = now.strftime(\"%d/%m/%Y %H:%M:%S\")\n\n pdf = FPDF()\n pdf.set_title(\"training_summary_{}_{}\".format(model_name.lower(), dt_string))\n pdf.add_page()\n pdf.set_xy(0, 10)\n pdf.set_font(\"Helvetica\", \"BI\", 16)\n pdf.set_text_color(25, 33, 78)\n pdf.set_draw_color(25, 33, 78)\n pdf.cell(20)\n pdf.cell(\n 200,\n 10,\n \"Model Training Summary: {}\".format(model_name.upper()),\n 0,\n 2,\n )\n pdf.set_font(\"Helvetica\", \"B\", 12)\n pdf.cell(\n 200,\n 5,\n dt_string,\n 0,\n 2,\n )\n\n # Model Configuration Section\n pdf.cell(150, 10, \"Model Configuration:\", 0, 2)\n pdf.cell(30, 10, \"Parameter\", 1, 0)\n pdf.cell(140, 10, \"Value\", 1, 2)\n pdf.set_text_color(255, 96, 80)\n pdf.set_font(\"Helvetica\", \"\", 12)\n pdf.cell(-30)\n attributes = [\n \"model_dir\",\n \"log_dir\",\n \"check_dir\",\n \"current_epoch\",\n \"overwrite\",\n \"exp_name\",\n ]\n for i, val in enumerate(hyperparams):\n if val not in attributes:\n pdf.cell(30, 10, \"%s\" % (val), 1, 0)\n pdf.cell(140, 10, \"%s\" % (hyperparams[val]), 1, 2)\n pdf.cell(-30)\n pdf.cell(90, 3, \"\", 0, 2)\n\n # Model Performance Section\n pdf.set_text_color(25, 33, 78)\n pdf.set_font(\"Helvetica\", \"B\", 12)\n pdf.cell(150, 10, \"Model Performance Stats:\", 0, 2)\n pdf.set_font(\"Helvetica\", \"\", 12)\n\n loss = train_stats[\"test_loss\"]\n acc = train_stats[\"test_acc\"]\n\n pdf.set_text_color(255, 96, 80)\n pdf.cell(35, 6, \"Best Loss:\", 0, 0)\n pdf.cell(\n 45, 6, \"{:.3f} (Epoch {})\".format(min(loss), loss.index(min(loss)) + 1), 0, 0\n )\n pdf.cell(60, 6, \"Training Duration:\", 0, 0)\n pdf.cell(30, 6, \"{:.3f} (s)\".format(train_stats[\"total_dur\"]), 0, 2)\n pdf.cell(-140)\n pdf.cell(35, 6, f\"Best Accuracy:\", 0, 0)\n pdf.cell(45, 6, \"{:.3f} (Epoch {})\".format(max(acc), acc.index(max(acc)) + 1), 0, 0)\n pdf.cell(60, 6, \"Average Epoch Duration:\", 0, 0)\n pdf.cell(\n 30,\n 6,\n \"{:.3f} (s)\".format(train_stats[\"total_dur\"] / hyperparams[\"current_epoch\"]),\n 0,\n 2,\n )\n pdf.cell(-140)\n pdf.cell(90, 3, \"\", 0, 2)\n\n # Loss Curve Section\n pdf.set_text_color(25, 33, 78)\n pdf.set_font(\"Helvetica\", \"B\", 12)\n pdf.cell(150, 10, \"Model Loss Curve:\", 0, 2)\n pdf.image(img_path, x=None, y=None, w=160, h=0, type=\"PNG\", link=\"\")\n\n # Second Page of Report\n pdf.add_page()\n pdf.set_xy(0, 0)\n pdf.cell(20, 20)\n\n # Model Arch Section\n pdf.cell(150, 20, \"Model Configuration:\", 0, 2)\n pdf.set_font(\"Helvetica\", \"\", 12)\n if model_arch is None:\n model_arch = \"No model configuration was provided\"\n pdf.set_text_color(255, 96, 80)\n pdf.multi_cell(180, 8, str(model_arch))\n\n # Third Page of Report\n pdf.add_page()\n pdf.set_xy(0, 0)\n pdf.cell(20, 20, \" \")\n\n # Training Loss Section\n pdf.set_text_color(25, 33, 78)\n pdf.set_font(\"Helvetica\", \"B\", 12)\n pdf.cell(150, 20, \"Detailed Loss Output:\", 0, 2)\n pdf.cell(40, 8, \"Epoch\", 1, 0, \"C\")\n pdf.cell(30, 8, \"Train Loss\", 1, 0, \"C\")\n pdf.cell(30, 8, \"Test Loss\", 1, 0, \"C\")\n pdf.cell(30, 8, \"Train Acc\", 1, 0, \"C\")\n pdf.cell(30, 8, \"Test Acc\", 1, 2, \"C\")\n pdf.set_text_color(255, 96, 80)\n pdf.set_font(\"Helvetica\", \"\", 12)\n pdf.cell(-130)\n for i in range(0, len(train_stats[\"train_loss\"])):\n pdf.cell(40, 8, \"{}\".format((i + 1)), 1, 0, \"C\")\n pdf.cell(30, 8, \"{:.3f}\".format((train_stats[\"train_loss\"][i])), 1, 0, \"C\")\n pdf.cell(30, 8, \"{:.3f}\".format((train_stats[\"test_loss\"][i])), 1, 0, \"C\")\n pdf.cell(30, 8, \"{:.3f}\".format((train_stats[\"train_acc\"][i])), 1, 0, \"C\")\n pdf.cell(30, 8, \"{:.3f}\".format((train_stats[\"test_acc\"][i])), 1, 2, \"C\")\n pdf.cell(-130)\n pdf.cell(90, 3, \"\", 0, 2)\n\n pdf.output(\n os.path.join(\n os.path.dirname(img_path),\n \"training_summary_{}.pdf\".format(model_name.lower()),\n ),\n \"F\",\n )","def LogProgress(model, writer, test_loader, epoch, device): \n\n model.eval() \n sequential = test_loader\n sample_batched = next(iter(sequential))\n \n image = torch.Tensor(sample_batched[\"image\"]).to(device)\n depth = torch.Tensor(sample_batched[\"depth\"]).to(device)\n \n if epoch == 0:\n writer.add_image(\"Train.1.Image\", vision_utils.make_grid(image.data, nrow=6, normalize=True), epoch)\n if epoch == 0:\n writer.add_image(\"Train.2.Image\", colorize(vision_utils.make_grid(depth.data, nrow=6, normalize=False)), epoch)\n \n output = DepthNorm(model(image))\n\n writer.add_image(\"Train.3.Ours\", colorize(vision_utils.make_grid(output.data, nrow=6, normalize=False)), epoch)\n writer.add_image(\"Train.4.Diff\", colorize(vision_utils.make_grid(torch.abs(output-depth).data, nrow=6, normalize=False)), epoch)\n \n del image\n del depth\n del output","def print_info(self):\r\n self.system.print_to_log(\r\n f\"{self.__class__.__name__} model: Infection probability: {self.p}, Infectious period: {self.i}, Recovery period: {self.r}.\")","def summary(self, test_type='t-test'):\n summary = f'Results for running {self.cv_method} evaluation for {self.method} '\n summary += f'on {self.n_model} models:\\n\\n'\n name_length = max([max(len(m.name) for m in self.models) + 1, 6])\n means = self.get_means()\n sems = self.get_sem()\n if means is None:\n means = np.nan * np.ones(self.n_model)\n if sems is None:\n sems = np.nan * np.ones(self.n_model)\n try:\n p_zero = self.test_zero(test_type=test_type)\n p_noise = self.test_noise(test_type=test_type)\n except ValueError:\n p_zero = np.nan * np.ones(self.n_model)\n p_noise = np.nan * np.ones(self.n_model)\n # header of the results table\n summary += 'Model' + (' ' * (name_length - 5))\n summary += '| Eval \\u00B1 SEM |'\n summary += ' p (against 0) |'\n summary += ' p (against NC) |\\n'\n summary += '-' * (name_length + 51)\n summary += '\\n'\n for i, m in enumerate(self.models):\n summary += m.name + (' ' * (name_length - len(m.name)))\n summary += f'| {means[i]: 5.3f} \\u00B1 {sems[i]:4.3f} |'\n if p_zero[i] < 0.001:\n summary += ' < 0.001 |'\n else:\n summary += f'{p_zero[i]:>13.3f} |'\n if p_noise[i] < 0.001:\n summary += ' < 0.001 |'\n else:\n summary += f'{p_noise[i]:>14.3f} |'\n summary += '\\n'\n summary += '\\n'\n if self.cv_method == 'crossvalidation':\n summary += 'No p-values available as crossvalidation provides no variance estimate'\n elif test_type == 't-test':\n summary += 'p-values are based on uncorrected t-tests'\n elif test_type == 'bootstrap':\n summary += 'p-values are based on percentiles of the bootstrap samples'\n elif test_type == 'ranksum':\n summary += 'p-values are based on ranksum tests'\n return summary","def print_model_description(verbose: bool):\n\n desc = get_model_description()\n description = f\"\"\"\nModel ID: {desc['id']}\nRelease Date: {desc['releaseDate']}\nCavity Labels: {desc['cavityLabels']}\nFault Labels: {desc['faultLabels']}\nTraining Data: {desc['trainingData']}\nBrief: {desc['brief']}\n\"\"\"\n if verbose:\n description += os.linesep + f\"Details: {desc['details']}\"\n print(description)","def torch_summarize(model, show_weights=True, show_parameters=True):\n tmpstr = model.__class__.__name__ + ' (\\n'\n for key, module in model._modules.items():\n # if it contains layers let call it recursively to get params and weights\n if type(module) in [\n torch.nn.modules.container.Container,\n torch.nn.modules.container.Sequential\n ]:\n modstr = torch_summarize(module)\n else:\n modstr = module.__repr__()\n modstr = _addindent(modstr, 2)\n\n params = sum([np.prod(p.size()) for p in module.parameters()])\n weights = tuple([tuple(p.size()) for p in module.parameters()])\n\n tmpstr += ' (' + key + '): ' + modstr\n if show_weights:\n tmpstr += ', weights={}'.format(weights)\n if show_parameters:\n tmpstr += ', parameters={}'.format(params)\n tmpstr += '\\n'\n\n tmpstr = tmpstr + ')'\n return tmpstr","def log_model(self, model_name=\"fixmatch_model\"):\n \n assert hasattr(self, \"_mlflow\"), \"need to run track_with_mlflow() first\"\n from mlflow.keras import log_model\n log_model(self._models[\"full\"], model_name)","def create_log(self):\n self.model.graph.get_stats()\n out = self.model.graph.summary\n out[\"training_error\"] = zip(self.train_it, self.train_err)\n out[\"validation_error\"] = zip(self.validation_it, self.validation_err)\n with open(self.log, \"w\") as f:\n f.write(json.dumps(out, default=defaultencode))","def save_arch(model, save_folder):\n with open(save_folder + '/architecture.txt','w') as a_save:\n model.summary(print_fn=lambda x: a_save.write(x + '\\n'))","def print_summary(self):\n self.network.print_summary()","def Plot_model_diagram(model, save= True):\n if save:\n keras.utils.plot_model(model, to_file= \"images/CNN_SE_model.png\")\n else:\n keras.utils.plot_model(model)","def summary_info(self):\n return [('model_architecture', self.model_architecture),\n ('input_size', self.input_size),\n ('output_size', self.output_size),\n ('hidden_layers', self.hidden_layers),\n ('learn_rate', self.learn_rate),\n ('drop_p', self.drop_p),\n ('current_epoch', self.model.current_epoch)]","def visualize_model(model=None, filename=\"InceptionV3_visualization.png\"):\n if model is None:\n p_model = InceptionV3(weights='imagenet', include_top=False)\n else:\n p_model = model\n keras.utils.plot_model(p_model, to_file=filename)","def add_summary(self):\n merged = tf.summary.merge_all()\n self.file_writer = tf.summary.FileWriter(self.FLAGS.model_dir, self.session.graph)","def ols_summary(output_dir: str, model: OLSModel,\n tree: TreeNode) -> None:\n warnings.warn(\"This visualization are deprecated.\", DeprecationWarning)\n # Cross validation\n w, h = 500, 300 # plot width and height\n\n # Explained sum of squares\n ess = model.ess\n # Summary object\n _k, _l = model.kfold(), model.lovo()\n smry = model.summary(_k, _l)\n _deposit_results(model, output_dir)\n t = _decorate_tree(tree, ess)\n\n p1 = radialplot(t, figsize=(800, 800))\n p1.title.text = 'Explained Sum of Squares'\n p1.title_location = 'above'\n p1.title.align = 'center'\n p1.title.text_font_size = '18pt'\n\n # 2D scatter plot for prediction on PB\n p2 = _projected_prediction(model, plot_width=w, plot_height=h)\n p3 = _projected_residuals(model, plot_width=w, plot_height=h)\n hm_p = _heatmap_summary(model.pvalues.T, model.coefficients().T)\n\n # combine the cross validation, explained sum of squares tree and\n # residual plots into a single plot\n p = row(column(p2, p3), p1)\n p = column(hm_p, p)\n index_fp = os.path.join(output_dir, 'index.html')\n with open(index_fp, 'w') as index_f:\n index_f.write('<html><body>\\n')\n index_f.write('<h1>Simplicial Linear Regression Summary</h1>\\n')\n index_f.write(smry.as_html())\n index_f.write(\n ('<th>Coefficients</th>\\n'\n '<a href=\"coefficients.csv\">'\n 'Download as CSV</a><br>\\n'\n '<th>Coefficient pvalues</th>\\n'\n '<a href=\"pvalues.csv\">'\n 'Download as CSV</a><br>\\n'\n '<th>FDR corrected coefficient pvalues</th>\\n'\n '<a href=\"fdr-corrected-pvalues.csv\">'\n 'Download as CSV</a><br>\\n'\n '<th>Predicted Balances</th>\\n'\n '<a href=\"predicted.csv\">'\n 'Download as CSV</a><br>\\n'\n '<th>Residuals</th>\\n'\n '<a href=\"residuals.csv\">'\n 'Download as CSV</a><br>\\n')\n )\n\n plot_html = file_html(p, CDN, 'Diagnostics')\n index_f.write(plot_html)\n index_f.write('</body></html>\\n')","def summary(self):\n if self.model_type == 2:\n if self.std is None:\n print(\n dedent(\n f\"\"\"\\\n Oaxaca-Blinder Two-fold Effects\n Unexplained Effect: {self.params[0]:.5f}\n Explained Effect: {self.params[1]:.5f}\n Gap: {self.params[2]:.5f}\"\"\"\n )\n )\n else:\n print(\n dedent(\n \"\"\"\\\n Oaxaca-Blinder Two-fold Effects\n Unexplained Effect: {:.5f}\n Unexplained Standard Error: {:.5f}\n Explained Effect: {:.5f}\n Explained Standard Error: {:.5f}\n Gap: {:.5f}\"\"\".format(\n self.params[0],\n self.std[0],\n self.params[1],\n self.std[1],\n self.params[2],\n )\n )\n )\n if self.model_type == 3:\n if self.std is None:\n print(\n dedent(\n f\"\"\"\\\n Oaxaca-Blinder Three-fold Effects\n Endowment Effect: {self.params[0]:.5f}\n Coefficient Effect: {self.params[1]:.5f}\n Interaction Effect: {self.params[2]:.5f}\n Gap: {self.params[3]:.5f}\"\"\"\n )\n )\n else:\n print(\n dedent(\n f\"\"\"\\\n Oaxaca-Blinder Three-fold Effects\n Endowment Effect: {self.params[0]:.5f}\n Endowment Standard Error: {self.std[0]:.5f}\n Coefficient Effect: {self.params[1]:.5f}\n Coefficient Standard Error: {self.std[1]:.5f}\n Interaction Effect: {self.params[2]:.5f}\n Interaction Standard Error: {self.std[2]:.5f}\n Gap: {self.params[3]:.5f}\"\"\"\n )\n )","def printModel(self, model):\n print(\"[L DIAG] startLoop =\", model.evaluate(self.startLoop))\n print(\"[L DIAG] endLoop =\", model.evaluate(self.endLoop))\n print(\"[L DIAG] projStartStateFaulty =\", model.evaluate(self.projStartStateFaulty))\n print(\"[L DIAG] projEndStateFaulty =\", model.evaluate(self.projEndStateFaulty))\n print(\"[L DIAG] projStartStateNormal =\", model.evaluate(self.projStartStateNormal))\n print(\"[L DIAG] projEndStateNormal =\", model.evaluate(self.projEndStateNormal))\n\n print(\"[L DIAG] stateFaultyPath: \")\n self.printOneIntArray(model, self.stateFaultyPath)\n print(\"[L DIAG] stateNormalPath: \")\n self.printOneIntArray(model, self.stateNormalPath)\n\n print()\n super().printModel(model)","def save_architecture(model, path_out):\n # Redirect the print output the a textfile\n orig_stdout = sys.stdout\n # and store the architecture\n f = file(os.path.join(path_out, \"architecture.txt\"), 'w')\n sys.stdout = f\n model.summary()\n # Reset the print output direction\n sys.stdout = orig_stdout\n f.close()\n\n open(os.path.join(path_out, \"config.json\"), 'w').write(model.to_json())","def test_get_summary_no_model(self):\n\t\t\n\t\tdescription = self.watcher.describe(model=self.model)\n\t\tself.assertEqual(11, len(description))\n\t\t\n\t\t\n\t\tdetails = self.watcher.analyze(model=self.model, layers=[self.fc2_layer])\n\t\treturned_summary = self.watcher.get_summary(details)\n\t\t\n\t\tprint(returned_summary)\n\t\t\n\t\tsaved_summary = self.watcher.get_summary()\n\t\tself.assertEqual(returned_summary, saved_summary)","def info(model: str = None) -> dict:\n model_instance = get_model(model)\n log.debug(\"Get info for \" + str(model_instance))\n return model_instance.info()","def save_model(self):\n\n print('Save model')\n self.feature_extractor.save_weights(\n self.path_save_model + self.name_model + '.h5')\n\n print('Mean and std')\n np.save(self.path_save_model + 'mean.npy', self.mean)\n np.save(self.path_save_model + 'std.npy', self.std)","def save_model(model):\n # ***\n # Please remove the comment to enable model save.\n # However, it will overwrite the baseline model we provided.\n # ***\n model.save(\"model/model.h5\")\n print(\"Model Saved Successfully.\")","def dispPowerSum(model):\n print(\"*** System Power Overview ***\")\n print(\"Pm:\\t%.3f\" % model.ss_Pm)\n print(\"Pe:\\t%.3f\" % model.ss_Pe)\n print(\"Pacc:\\t%.3f\" % model.ss_Pacc)\n print(\"Pload:\\t%.3f\" % model.ss_Pload)\n print(\"Ploss:\\t%.3f\" % model.PLosses)\n print(\"*_*\")\n #NOTE: Q values are meaningless until Shunts and SVDs are accounted for\n print(\"Qgen:\\t%.3f\" % model.ss_Qgen)\n print(\"Qload:\\t%.3f\" % model.ss_Qload)\n print(\"Qloss:\\t%.3f\" % model.QLosses)\n print(\"***_______________________***\")","def model_info(model):\n return juju.CLIENT.Client(request=\"ModelInfo\",\n params={\"Name\": model})","def execute_summary(self, step):\n with self.summary_writer.as_default():\n tf.summary.scalar('bias', self.core.fmlayer.b, step=step)\n tf.summary.scalar('regularization_penalty', self.regularization, step=step)\n tf.summary.scalar('loss', self.reduced_loss, step=step)\n tf.summary.scalar('target', self.target, step=step)","def define_model(model):\n global log_data_likelihood, log_priors, num_params, file_labels, labels, prior_xs, prior_pdfs\n num_prior_pts = 1001\n pic50_lower = -4.\n pic50_upper = 14.\n hill_lower = 0.\n hill_upper = 6.\n if model == 1:\n num_params = 2\n log_data_likelihood = log_data_likelihood_model_1_capped\n log_priors = log_priors_model_1\n labels = [r\"$pIC50$\", r\"$\\sigma$\"]\n file_labels = ['pIC50','sigma']\n #prior_xs = [np.linspace(pic50_lower, pic50_upper, num_prior_pts),\n # np.linspace(sigma_uniform_lower,sigma_uniform_upper,num_prior_pts)]\n prior_xs = [np.linspace(pic50_exp_lower-2, pic50_exp_lower+23, num_prior_pts),\n np.linspace(0, 25, num_prior_pts)]\n #prior_pdfs = [st.logistic.pdf(prior_xs[0], loc=mu, scale=s),\n # np.ones(num_prior_pts)/(1.*sigma_uniform_upper-sigma_uniform_lower)]\n #prior_pdfs = [st.expon.pdf(prior_xs[0], loc=pic50_exp_lower, scale=pic50_exp_scale),\n # np.concatenate(([0,0],np.ones(num_prior_pts)/(1.*sigma_uniform_upper-sigma_uniform_lower),[0,0]))]\n prior_pdfs = [st.expon.pdf(prior_xs[0], loc=pic50_exp_lower, scale=pic50_exp_scale),\n st.gamma.pdf(prior_xs[1], sigma_shape, loc=sigma_loc, scale=sigma_scale)]\n elif model == 2:\n num_params = 3\n log_data_likelihood = log_data_likelihood_model_2_capped\n log_priors = log_priors_model_2\n labels = [r\"$pIC50$\", r\"$Hill$\", r\"$\\sigma$\"]\n file_labels = ['pIC50','Hill','sigma']\n #prior_xs = [np.linspace(pic50_lower, pic50_upper, num_prior_pts),\n # np.linspace(hill_lower, hill_upper, num_prior_pts),\n # np.linspace(sigma_uniform_lower,sigma_uniform_upper,num_prior_pts)]\n prior_xs = [np.linspace(pic50_exp_lower-2, pic50_exp_lower+23, num_prior_pts),\n np.concatenate(([hill_uniform_lower-2,hill_uniform_lower],\n np.linspace(hill_uniform_lower, hill_uniform_upper, num_prior_pts),\n [hill_uniform_upper,hill_uniform_upper+2])),\n np.linspace(0, 25, num_prior_pts)]\n #prior_pdfs = [st.logistic.pdf(prior_xs[0],loc=mu,scale=s),\n # st.fisk.pdf(prior_xs[1],c=beta,scale=alpha),\n # np.ones(num_prior_pts)/(1.*sigma_uniform_upper-sigma_uniform_lower)]\n #prior_pdfs = [st.expon.pdf(prior_xs[0], loc=pic50_exp_lower, scale=pic50_exp_scale),\n # np.concatenate(([0,0],np.ones(num_prior_pts) / (1. * hill_uniform_upper - hill_uniform_lower),[0,0])),\n # np.concatenate(([0, 0], np.ones(num_prior_pts) / (1. * sigma_uniform_upper - sigma_uniform_lower), [0, 0]))]\n prior_pdfs = [st.expon.pdf(prior_xs[0], loc=pic50_exp_lower, scale=pic50_exp_scale),\n np.concatenate(([0,0],np.ones(num_prior_pts) / (1. * hill_uniform_upper - hill_uniform_lower),[0,0])),\n st.gamma.pdf(prior_xs[2], sigma_shape, loc=sigma_loc, scale=sigma_scale)]","def get_summary_model(processed_text, model_type, number_topics):\n\n if model_type == 'LDA':\n count_model = CountVectorizer(ngram_range=(1, 1)).fit(processed_text)\n return count_model, LDA(n_components=number_topics, learning_method='batch').fit(count_model.fit_transform(processed_text))\n if model_type == 'LSA':\n tf_idf_model = TfidfVectorizer(ngram_range=(1, 1)).fit(processed_text)\n return tf_idf_model, TruncatedSVD(n_components=number_topics, algorithm='randomized', n_iter=100, random_state=122).fit(tf_idf_model.transform(processed_text))\n else:\n tf_idf_model = TfidfVectorizer(ngram_range=(1, 1)).fit(processed_text)\n return tf_idf_model, NMF(n_components=number_topics, init='random', random_state=0).fit(tf_idf_model.transform(processed_text))","def model_analysis(self, model_name: str, history) -> None:\n # probabilites\n y_pred_prob = self.recognizer.predict(self.X_test)\n # most likely class\n y_pred = np.argmax(y_pred_prob, axis=1)\n # compare true and predicted classes on test set\n\n # path handling for writing to file\n output_dir = Path(os.environ[\"MODEL_DATA\"]) / model_name\n out_name = \"classification_report.txt\"\n out_path = output_dir / out_name\n\n acc = history.history[\"accuracy\"]\n val_acc = history.history[\"val_accuracy\"]\n loss = history.history[\"loss\"]\n val_loss = history.history[\"val_loss\"]\n\n epochs = range(1, len(acc) + 1)\n\n # plot accuracies and losses with respect to epochs\n plt.plot(epochs, acc, \"r\", label=\"Train accuracy\")\n plt.plot(epochs, val_acc, \"b\", label=\"Val accuracy\")\n\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Accuracy\")\n plt.legend()\n\n plt.savefig(output_dir / \"acc-plot\")\n\n plt.figure()\n plt.plot(epochs, loss, \"r\", label=\"Training loss\")\n plt.plot(epochs, val_loss, \"b\", label=\"Val loss\")\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.legend()\n\n plt.savefig(output_dir / \"loss-plot\")\n\n # create, print and write to file a sklearn classification report\n print(set(self.y_test) - set(y_pred))\n report = classification_report(self.y_test, y_pred)\n print(report)\n with open(out_path, \"w\") as f:\n f.write(report)\n\n self.make_heatmap(y_pred, output_dir)","def get_summary_from_model(text, model_type, number_words, target_percentage, nlp):\n\n # get sentences from text\n sentences = [sentence for sentence in\n text.lower().replace('!', '.').replace('?', '.').split('.')]\n\n # this pre-processing removes junk characters, and converts all sentence-ending characters to full-stops, for the\n # purpose of splitting the text into sentences\n processed_text = [convert_to_string(\n lemmatize(convert_to_string(remove_non_words(remove_stop_words(tokenize_text(sentence, nlp)))), nlp)) for\n sentence in sentences]\n\n # begin generating topics from the text, beginning with 1 topic\n number_topics = 1\n nlp_model, summary_model = get_summary_model(processed_text, model_type, number_topics)\n topic_sentences = get_topics(summary_model, nlp_model, number_words)\n percentage = len('. '.join(full_summarizer_word_comparison(sentences, topic_sentences, number_topics))) / len(text)\n\n # check if the ratio of the summary to the text is below the user-defined threshold\n while percentage < target_percentage:\n number_topics += 1\n nlp_model, summary_model = get_summary_model(processed_text, model_type, number_topics)\n topic_sentences = get_topics(summary_model, nlp_model, number_words)\n percentage = len('. '.join(full_summarizer_word_comparison(sentences, topic_sentences, number_topics))) / len(text)\n\n return '. '.join(full_summarizer_word_comparison(sentences, topic_sentences, number_topics))","def save_information(self, path: utils.URLPath):\n # Text summary of model\n with (path / \"model_summary.txt\").open(\"w\") as summary_file:\n def print_file(*args, **kwargs):\n print(*args, **kwargs, file=summary_file)\n self.model.summary(print_fn=print_file)\n\n # Image plotting structure of model\n keras.utils.plot_model(self.model, to_file=str(path / \"model_plot.png\"))\n\n # plot all training history\n for i, (meta, history) in enumerate(self.training_history):\n training_output = path / f\"train_{i}\"\n io_functions.save_json(meta, training_output / \"info.json\")\n plot_training_history(history, training_output / \"training.png\")","def dump_model(self):","def _setup_summaries(self, sess):\n # Output directory for models and summaries\n\n\n print(\"Writing to {}\\n\".format(os.path.abspath(self._log_dir)))\n\n train_summary_dir = os.path.join(self._log_dir, \"summaries\", \"train\")\n self._train_summary_writer = tf.summary.FileWriter(train_summary_dir, sess.graph)\n\n val_summary_dir = os.path.join(self._log_dir, \"summaries\", \"validation\")\n self._val_summary_writer = tf.summary.FileWriter(val_summary_dir, sess.graph)\n\n # Model checkpoints\n # Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it\n self.checkpoint_dir = os.path.abspath(os.path.join(self._save_dir, \"checkpoints/\"))\n\n if not os.path.exists(self.checkpoint_dir):\n os.makedirs(self.checkpoint_dir)\n\n self._saver = tf.train.Saver(max_to_keep=10) # Save model after each epoch\n\n self.train_summary_op = tf.summary.merge(self._train_summaries)\n self.val_summary_op = tf.summary.merge(self._val_summaries)\n\n print(\"--------------------------------------------------\")\n print(\"\\ntensorboard --logdir {}\".format(os.path.abspath(self._log_dir)))\n print(\"\\ntensorboard --logdir {} --port 6007\".format(os.path.abspath(self.checkpoint_dir)))\n print(\"--------------------------------------------------\")","def printModelAndTime(self):\n import time\n self._reporter.writeOutput(\"Model name = \" + self.modelName + '\\n' +\n \"Output directory = \" + self._outputDir_ + '\\n' +\n \"Time = \" + time.asctime() + '\\n')\n return","def generate_im(self, model):\n kappa = kappy.KappaStd()\n model_str = export.export(model, 'kappa')\n kappa.add_model_string(model_str)\n kappa.project_parse()\n imap = kappa.analyses_influence_map(accuracy='medium')\n graph = im_json_to_graph(imap)\n return graph","def _publish_model(self):\n # Check if already published\n if self.model_published:\n return\n\n # Trace CPO model if required\n ctx = self.context\n lout = ctx.get_log_output()\n if lout and ctx.solver.trace_cpo:\n stime = time.time()\n lout.write(\"Model '\" + str(self.model.get_name()) + \"' in CPO format:\\n\")\n lout.write(self.cpostr)\n lout.write(\"\\n\")\n self.model.write_information(lout)\n lout.write(\"\\n\")\n lout.flush()\n self.process_infos.incr(CpoProcessInfos.MODEL_DUMP_TIME, time.time() - stime)\n\n # Dump in dump directory if required\n if ctx.model.dump_directory:\n stime = time.time()\n make_directories(ctx.model.dump_directory)\n mname = self.model.get_name()\n if mname is None:\n mname = \"Anonymous\"\n else:\n # Remove special characters introduced by Jupyter\n mname = mname.replace('<', '').replace('>', '')\n file = ctx.model.dump_directory + \"/\" + mname + \".cpo\"\n with utils.open_utf8(file, 'w') as f:\n f.write(self.cpostr)\n self.process_infos.incr(CpoProcessInfos.MODEL_DUMP_TIME, time.time() - stime)\n\n # Set published indicator\n self.model_published = True","def print_model(self, model):\n return \"null\"","def _get_summary_struct(self):\n model_fields = [\n ('Number of classes', 'num_classes'),\n ('Number of feature columns', 'num_features'),\n ('Input image shape', 'input_image_shape'),\n ]\n training_fields = [\n ('Number of examples', 'num_examples'),\n (\"Training loss\", 'training_loss'),\n (\"Training time (sec)\", 'training_time'),\n ]\n\n section_titles = ['Schema', 'Training summary']\n return([model_fields, training_fields], section_titles)","def summary_page() :\r\n logger.debug(\"\")\r\n model = session_info.get_user_model(session)\r\n return render_template( \"summary_page.html\" , model=model ,\r\n stat_types=param_stats.StatTypes )","def summary(app):\n click.echo(get_summary(app))","def summary(self):\n\n print(\"input label:\", self.__input_label)\n print(\"target label:\", self.__target_label)\n print(\"denoising label:\", self.denoising_label)\n print(\"contains a successful DE:\", self.is_successful())","def create_summary_statistics(forward_accuracy, backward_accuracy, merged_accuracy):\n summary_statistics = open(f'summary_statistics.txt', 'a')\n summary_statistics.write(f'The forward model has an accuracy of: {forward_accuracy}\\n')\n summary_statistics.write(f'The backward model has an accuracy of: {backward_accuracy}\\n')\n summary_statistics.write(f'The merged model has an accuracy of: {merged_accuracy}\\n')\n summary_statistics.close()","def printModel(self):\n print(self.model)","def summary(self):\r\n self.base.summary()\r\n self.extra_layers.summary()\r\n self.detector.summary()","def save_graph_summary(self):\n writer = tf.summary.FileWriter(LOG_PATH)\n writer.add_graph(self.graph)","def summary(self, summary: str):\n return self.swag({\n 'summary': summary\n })","def show_performance(model):\n val_image_ids_ = [i for i in val_image_ids]\n np.random.shuffle(val_image_ids_)\n\n df_val = area_filter(val_image_ids_, val_coco)\n image_id = df_val['image_id'].iloc[0]\n annotation_ids = df_val[df_val['image_id'] == image_id]['annotation_id'].tolist()\n\n image_json = val_coco.loadImgs([image_id])[0]\n raw_image = cv2.imread(os.path.join(\"{}/{}/{}\".format(data_dir, val_type, image_json['file_name'])))\n height, width, _ = raw_image.shape\n\n # decode the mask, using annotation id created at the group by above\n binary_mask = process_mask(val_coco, annotation_ids, width, height)\n\n # preprocess input and mask (resize to 128, scale to [0, 1))\n input_image, input_mask = preprocess(raw_image, binary_mask)\n\n input_mask = np.expand_dims(input_mask, axis=-1)\n predicted_mask = model.predict(np.array([input_image]))[0]\n\n plt.figure(figsize=(20, 20))\n\n title = ['Input Image', 'True Mask', 'Predicted Mask']\n display_list = [input_image[:, :, ::-1], input_mask, predicted_mask]\n for i in range(len(display_list)):\n plt.subplot(1, len(display_list), i+1)\n plt.title(title[i])\n plt.imshow(array_to_img(display_list[i]))\n plt.axis('off')\n plt.show()","def save_model(model, loss, inner_val_loss, mean_outer_val_loss, mean_test_loss, fpath):\n\n\t# Dump data\n\twith open(fpath + '.json', 'w') as structure_fpath:\n\t\tjson.dump(model.to_json(), structure_fpath)\n\tlogging.info('...saved structural information')\n\n\t# Dump weights\n\tmodel.save_weights(fpath + '.h5', overwrite = True)\n\tlogging.info('...saved weights')\n\n\t# Dump image\n\ttry:\n\t\tplot(model, to_file = fpath + '.png')\n\t\tlogging.info('...saved image')\n\texcept:\n\t\tpass\n\n\t# Dump history\n\tsave_model_history_manual(loss, inner_val_loss, fpath + '.hist')\n\n\tmean_loss = loss[-1]\n\tmean_inner_val_loss = inner_val_loss[-1]\n\twrite_loss_report(mean_loss, mean_inner_val_loss, mean_outer_val_loss, mean_test_loss, fpath + '_loss_report.txt')\n\tlogging.info ('...saved history')\n\n\tlogging.info('...saved model to {}.[json, h5, png]'.format(fpath))","def ribovision_model_info(filename, output):\n r2dt.write_ribovision(filename, output)","def dump(self, model_name: str) -> None:\n # Dump each preprocessor\n for index, preprocessor in enumerate(self._preprocessors):\n model_filename = Files.MODEL_PREPROCESSOR_MODEL_FMT.format(\n model_name, index)\n joblib.dump(preprocessor, model_filename)\n\n # Dump the scalar\n filename = Files.MODEL_PREPROCESSOR_MODEL_FMT.format(\n model_name, Packages.Models.Training.SCALAR_MODEL_NAME)\n joblib.dump(self._last_scalar_model, filename)\n\n # Dump the dimensionality reduction model\n reduction_model_path = Files.MODEL_REDUCTION_MODEL_FMT.format(\n model_name)\n joblib.dump(self._reduction_model, reduction_model_path)","def summary(self):\n for i,layer in enumerate(self.chain):\n x = Input([2])\n y = layer.forward(x)\n Model(x,y,name=f'layer_{i}_summary').summary()","def load_model(self):\n self.loaded_model = keras.models.load_model(self.path)\n return self.loaded_model.summary()","def write(self, model):\n\n # Initialize json_dump\n json_dump = {\"model\": [], \"metadata\": {}}\n\n # Set timestamp in metadata\n json_dump[\"metadata\"][\"time\"] = str(datetime.now())\n\n # Set the size of the model in metadata\n json_dump[\"metadata\"][\"model_size\"] = len(model.models)\n\n for obj in model.models:\n _class = type(obj).__name__\n if _class in [\n Winding,\n PhaseWinding,\n Wire,\n PhaseCapacitor,\n Position,\n PhaseLoad,\n ]:\n continue\n json_dump[\"model\"].append({})\n json_dump[\"model\"][-1][\"class\"] = _class\n\n try:\n json_dump[\"model\"][-1][\"name\"] = {\"class\": \"str\", \"value\": obj.name}\n except:\n json_dump[\"model\"][-1][\"name\"] = {\"class\": \"str\", \"value\": None}\n pass\n\n for key, value in obj._trait_values.items():\n if key in [\"capacitance_matrix\", \"impedance_matrix\", \"reactances\"]:\n json_dump[\"model\"][-1][key] = {\"class\": \"list\", \"value\": []}\n for v in value:\n if isinstance(v, complex):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"complex\", \"value\": [v.real, v.imag]}\n )\n elif isinstance(v, list):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"list\", \"value\": []}\n )\n for vv in v:\n if isinstance(vv, complex):\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"value\"\n ].append(\n {\n \"class\": \"complex\",\n \"value\": [vv.real, vv.imag],\n }\n )\n else:\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"value\"\n ].append(\n {\n \"class\": str(type(vv)).split(\"'\")[1],\n \"value\": vv,\n }\n )\n else:\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": str(type(v)).split(\"'\")[1], \"value\": v}\n )\n continue\n if isinstance(value, list):\n json_dump[\"model\"][-1][key] = {\"class\": \"list\", \"value\": []}\n for v in value:\n\n if isinstance(v, complex):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"complex\", \"value\": [v.real, v.imag]}\n )\n\n elif isinstance(v, Position):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"Position\"}\n )\n for kkk, vvv in v._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n\n elif isinstance(v, Unicode):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"Unicode\", \"value\": v.default_value}\n )\n\n elif isinstance(v, Wire):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"Wire\"}\n )\n for kkk, vvv in v._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n\n elif isinstance(v, PhaseCapacitor):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"PhaseCapacitor\"}\n )\n for kkk, vvv in v._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n\n elif isinstance(v, Winding):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"Winding\"}\n )\n for kkk, vvv in v._trait_values.items():\n if kkk != \"phase_windings\":\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"phase_windings\"\n ] = {\"class\": \"list\", \"value\": []}\n for phw in v.phase_windings:\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"phase_windings\"\n ][\"value\"].append({\"class\": \"PhaseWinding\"})\n for kkkk, vvvv in phw._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"phase_windings\"\n ][\"value\"][-1][kkkk] = {\n \"class\": str(type(vvvv)).split(\"'\")[1],\n \"value\": vvvv,\n }\n\n elif isinstance(v, PhaseLoad):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"PhaseLoad\"}\n )\n for kkk, vvv in v._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n\n continue\n\n if isinstance(value, complex):\n json_dump[\"model\"][-1][key] = {\n \"class\": \"complex\",\n \"value\": [value.real, value.imag],\n }\n continue\n\n json_dump[\"model\"][-1][key] = {\n \"class\": str(type(value)).split(\"'\")[1],\n \"value\": value,\n }\n\n with open(os.path.join(self.output_path, self.filename), \"w\") as f:\n f.write(\n json_tricks.dumps(json_dump, allow_nan=True, sort_keys=True, indent=4)\n )","def log_model_info(log_file: str, full_train_state: train_state_lib.TrainState,\n partitioner: partitioning.BasePartitioner):\n # Only write logs on host 0.\n if jax.process_index() != 0:\n return\n\n state_dict = full_train_state.state_dict()\n param_state_dict = state_dict['target']\n total_num_params = jax.tree_util.tree_reduce(\n np.add, jax.tree_map(np.size, param_state_dict))\n\n param_logical_axes = partitioner.get_logical_axes(\n full_train_state).state_dict()['target']\n\n param_mesh_axes = jax.tree_map(\n lambda x: tuple(x) if x is not None else None,\n partitioner.get_mesh_axes(full_train_state).state_dict()['target'])\n\n def _log_info_and_write_to_file(writer, format_str, *args):\n logging.info(format_str, *args)\n writer.write(format_str % args + '\\n')\n\n with gfile.GFile(log_file, 'w') as writer:\n\n # Log params\n def _log_param(name: str, arr: np.ndarray,\n logical_axes: Optional[partitioning.AxisNames],\n mesh_axes: Optional[partitioning.PartitionSpec]):\n if logical_axes is None:\n shape_str = str(arr.shape)\n else:\n assert len(logical_axes) == len(arr.shape)\n shape_str = '({})'.format(', '.join(\n f'{name}={dimension}'\n for name, dimension in zip(logical_axes, arr.shape)))\n _log_info_and_write_to_file(\n writer, 'Variable %-80s size %-12s shape %-40s partition spec %s',\n name, arr.size, shape_str, mesh_axes)\n\n jax.tree_map(_log_param, state_utils.get_name_tree(param_state_dict),\n param_state_dict, param_logical_axes, param_mesh_axes)\n\n _log_info_and_write_to_file(writer, 'Total number of parameters: %d',\n total_num_params)\n\n # Add a blank line between params and states.\n _log_info_and_write_to_file(writer, '')\n\n # Log states\n def _log_state(name, arr):\n if arr is None:\n _log_info_and_write_to_file(writer, 'State %-80s None', name)\n else:\n _log_info_and_write_to_file(writer,\n 'State %-80s size %-12s shape %s', name,\n arr.size, arr.shape)\n\n jax.tree_map(_log_state, state_utils.get_name_tree(state_dict['state']),\n state_dict['state'])"],"string":"[\n \"def generate_and_print_model_summary(config: ModelConfigBase, model: DeviceAwareModule) -> None:\\n random_state = RandomStateSnapshot.snapshot_random_state()\\n # There appears to be a bug in apex, where previous use (in training for example) causes problems\\n # when another model is later built on the CPU (for example, before loading from a checkpoint)\\n # https://github.com/NVIDIA/apex/issues/694\\n # Hence, move the model to the GPU before doing model summary.\\n if config.use_gpu:\\n model = model.cuda()\\n if isinstance(config, ScalarModelBase):\\n # To generate the model summary, read the first item of the dataset. Then use the model's own\\n # get_model_input function to convert the dataset item to input tensors, and feed them through the model.\\n train_dataset = config.get_torch_dataset_for_inference(ModelExecutionMode.TRAIN)\\n train_item_0 = next(iter(train_dataset.as_data_loader(shuffle=False, batch_size=1, num_dataload_workers=0)))\\n model_inputs = get_scalar_model_inputs_and_labels(config, model, train_item_0).model_inputs\\n # The model inputs may already be converted to float16, assuming that we would do mixed precision.\\n # However, the model is not yet converted to float16 when this function is called, hence convert back to float32\\n summary = ModelSummary(model)\\n summary.generate_summary(input_tensors=model_inputs, log_summaries_to_files=config.log_summaries_to_files)\\n elif config.is_segmentation_model:\\n summary_for_segmentation_models(config, model)\\n assert model.summarizer\\n summary = model.summarizer # type: ignore\\n else:\\n raise ValueError(\\\"Don't know how to generate a summary for this type of model?\\\")\\n RUN_CONTEXT.log(LoggingColumns.NumTrainableParameters, summary.n_trainable_params)\\n random_state.restore_random_state()\",\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 summary(self):\\n\\n self.model.summary(print_fn=lambda x: logging.info(x))\",\n \"def model_summary_to_file(model, save_path):\\n with open(save_path, 'w') as fh:\\n model.summary(print_fn=lambda x: fh.write(x + \\\"\\\\n\\\"))\",\n \"def save_summary(model, model_name, stage_no):\\n stringlist = []\\n model.summary(print_fn=lambda x: stringlist.append(x))\\n short_model_summary = \\\"\\\\n\\\".join(stringlist)\\n \\n with open(eval_path+\\\"{}_model_summary_stage_{}.txt\\\".format(model_name, stage_no), \\\"w\\\") as text_file:\\n print(short_model_summary, file=text_file)\",\n \"def print_summary(self):\\n self.model.summary()\",\n \"def show_model_summary(self):\\n\\t\\treturn self.model.summary()\",\n \"def summarize_model(\\n model: keras.Model, fig_dir: Union[str, None] = None\\n) -> None:\\n\\n submodels = []\\n for layer in model.layers:\\n if isinstance(layer, TimeDistributed):\\n submodels.append(layer.layer)\\n\\n for submodel in submodels:\\n submodel.summary()\\n model.summary()\\n\\n if fig_dir is not None:\\n for submodel in submodels:\\n keras.utils.plot_model(\\n submodel, os.path.join(fig_dir, f'model_{submodel.name}.png'),\\n dpi=300\\n )\\n keras.utils.plot_model(\\n model, os.path.join(fig_dir, 'model_full.png'), dpi=300\\n )\",\n \"def model_stats(opt, epoch, model):\\n log = rlog.getLogger(opt.experiment + \\\".model\\\")\\n if hasattr(opt, \\\"log\\\") and opt.log.detailed:\\n # log histogram also\\n assert isinstance(\\n model, SVIModel\\n ), \\\"This stat only makes sense for SVI models.\\\"\\n for mu, std in zip(model.mu(), model.std()):\\n log.put(mu=mu, std=std)\\n log.trace(step=epoch, **model.summarize())\\n log.reset()\",\n \"def summary(self) -> None:\\n print(\\\"Model manager summary:\\\")\\n print(\\\"Preprocessor:\\\")\\n print(self.preprocessor)\\n print(\\\"Model summary:\\\")\\n self.model.summary()\\n print(\\\"Postprocessor:\\\")\\n print(self.postprocessor)\",\n \"def test_summaries(self):\\n try:\\n ans = str(self.model)\\n except:\\n assert False, \\\"Model __repr__ failed.\\\"\\n\\n try:\\n print(self.model)\\n except:\\n assert False, \\\"Model print failed.\\\"\\n\\n try:\\n self.model.summary()\\n except:\\n assert False, \\\"Model summary failed.\\\"\",\n \"def _save_model_info(self, model):\\r\\n with open_(self.output_path / \\\"model.info\\\", \\\"w+\\\") as f:\\r\\n f.write(model.info)\",\n \"def print_summary(self):\\n print(\\\"Word Level\\\")\\n self.model_word.summary()\\n \\n print(\\\"Sent Level\\\")\\n self.model_sent.summary()\\n\\n print(\\\"Doc Level\\\")\\n self.model.summary()\",\n \"def test_get_summary_with_model(self):\\n\\t\\t\\n\\t\\tdescription = self.watcher.describe(model=self.model)\\n\\t\\tself.assertEqual(11, len(description))\\n\\t\\t\\n\\t\\t\\n\\t\\tdetails = self.watcher.analyze(model=self.model, layers=[self.second_layer])\\n\\t\\treturned_summary = self.watcher.get_summary(details)\\n\\t\\t\\n\\t\\tprint(returned_summary)\\n\\t\\t\\n\\t\\tsaved_summary = self.watcher.get_summary()\\n\\t\\tself.assertEqual(returned_summary, saved_summary)\",\n \"def summary(self):\\r\\n print(self.model.summary())\",\n \"def summary(self):\\n print(self.model.summary())\",\n \"def output_summary(self, v, vhat, sk, logged_matrics, train_dataset_label, val_dataset_label, summary_folder_path):\\n\\n mse = np.sum((v-vhat)**2)/len(v)\\n train_loss = logged_matrics[\\\"train_loss\\\"]\\n\\n k = np.sum(p.numel() for p in self.parameters())\\n\\n numOfSamples = len(sk)\\n aic = 2*k + numOfSamples*np.log(mse) + numOfSamples*(1+np.log(2*np.pi))\\n\\n summary_file = os.path.join(summary_folder_path, \\\"model_summary.txt\\\")\\n if not os.path.isfile(summary_file):\\n print(\\\"Created file \\\"+summary_file)\\n with open(summary_file, \\\"w\\\") as output:\\n output.write(\\n \\\"Model Train_dataset_label Val_dataset_label Train_loss Test_loss AIC\\\\n\\\")\\n else:\\n print(summary_file +\\n \\\" exists, model summary will be attached to the end of this file.\\\")\\n\\n with open(summary_file, \\\"a\\\") as output:\\n model_name = self.version\\n output.write(model_name + \\\" \\\" + train_dataset_label + \\\" \\\" +\\n val_dataset_label + \\\" %f %f %f\\\\n\\\" % (train_loss, mse, aic))\\n\\n\\n plt.scatter(sk, v, c=\\\"blue\\\", s=2, label=\\\"true\\\")\\n plt.scatter(sk, vhat, c=\\\"red\\\", s=2, label=\\\"predict\\\")\\n plt.legend()\\n plt.xlabel(\\\"sk\\\")\\n plt.ylabel(\\\"v\\\")\\n\\n plt.savefig(os.path.join(summary_folder_path, \\\"plots\\\", model_name+\\\".png\\\"))\\n plt.show()\\n\\n np.savetxt(os.path.join(summary_folder_path, \\\"model_prediction\\\", model_name+\\\"_prediction.txt\\\"), np.column_stack((sk, v, vhat)), header=\\\"sk v vhat\\\", fmt='%.8f')\\n\\n\\n print(\\\"Plot saved as\\\", os.path.join(summary_folder_path, \\\"plots\\\", model_name+\\\".png\\\"))\\n print(\\\"Model prediction saved as\\\", os.path.join(summary_folder_path, \\\"model_prediction\\\", model_name+\\\"_prediction.txt\\\"))\",\n \"def log_model_analysis(\\n logger, image, segmentation_image, model, indices_to_colors_map, void_color, colors_to_ignore):\\n\\n ground_truth_overlay_image = net.utilities.get_segmentation_overlaid_image(\\n image, segmentation_image, colors_to_ignore)\\n\\n predicted_segmentation_cube = model.predict(image)\\n\\n predicted_segmentation_image = net.data.get_segmentation_image(\\n predicted_segmentation_cube, indices_to_colors_map, void_color)\\n\\n predicted_overlay_image = net.utilities.get_segmentation_overlaid_image(\\n image, predicted_segmentation_image, colors_to_ignore)\\n\\n logger.info(vlogging.VisualRecord(\\n \\\"Data\\\", [image, segmentation_image, predicted_segmentation_image,\\n ground_truth_overlay_image, predicted_overlay_image]))\",\n \"def summary(self):\\n self.model.summary()\",\n \"def review_model(model): \\n \\n diagnose_model(model)\\n \\n plot_param_coef(model)\\n \\n plot_p_values(model)\\n \\n return\",\n \"def lme_summary(output_dir: str, model: LMEModel, tree: TreeNode) -> None:\\n warnings.warn(\\\"This visualization are deprecated.\\\", DeprecationWarning)\\n # log likelihood\\n loglike = pd.Series({r.model.endog_names: r.model.loglike(r.params)\\n for r in model.results})\\n w, h = 500, 300 # plot width and height\\n # Summary object\\n smry = model.summary()\\n\\n t = _decorate_tree(tree, -loglike)\\n\\n p1 = radialplot(t, figsize=(800, 800))\\n p1.title.text = 'Loglikelihood of submodels'\\n p1.title_location = 'above'\\n p1.title.align = 'center'\\n p1.title.text_font_size = '18pt'\\n\\n # 2D scatter plot for prediction on PB\\n p2 = _projected_prediction(model, plot_width=w, plot_height=h)\\n p3 = _projected_residuals(model, plot_width=w, plot_height=h)\\n hm_p = _heatmap_summary(model.pvalues.T, model.coefficients().T,\\n plot_width=900, plot_height=400)\\n\\n # combine the cross validation, explained sum of squares tree and\\n # residual plots into a single plot\\n p = row(column(p2, p3), p1)\\n p = column(hm_p, p)\\n\\n # Deposit all regression results\\n _deposit_results(model, output_dir)\\n\\n index_fp = os.path.join(output_dir, 'index.html')\\n with open(index_fp, 'w') as index_f:\\n index_f.write('<html><body>\\\\n')\\n index_f.write('<h1>Simplicial Linear Mixed Effects Summary</h1>\\\\n')\\n index_f.write(smry.as_html())\\n index_f.write(\\n ('<th>Coefficients</th>\\\\n'\\n '<a href=\\\"coefficients.csv\\\">'\\n 'Download as CSV</a><br>\\\\n'\\n '<th>Coefficient pvalues</th>\\\\n'\\n '<a href=\\\"pvalues.csv\\\">'\\n 'Download as CSV</a><br>\\\\n'\\n '<th>FDR corrected coefficient pvalues</th>\\\\n'\\n '<a href=\\\"fdr-corrected-pvalues.csv\\\">'\\n 'Download as CSV</a><br>\\\\n'\\n '<th>Predicted Balances</th>\\\\n'\\n '<a href=\\\"predicted.csv\\\">'\\n 'Download as CSV</a><br>\\\\n'\\n '<th>Residuals</th>\\\\n'\\n '<a href=\\\"residuals.csv\\\">'\\n 'Download as CSV</a><br>\\\\n')\\n )\\n\\n diag_html = file_html(p, CDN, 'Diagnostic plots')\\n index_f.write(diag_html)\\n index_f.write('</body></html>\\\\n')\",\n \"def print_summary(self, print_level = 0):\\n\\n print(\\\"==========================\\\")\\n print(\\\"= FUNtoFEM model summary =\\\")\\n print(\\\"==========================\\\")\\n print(\\\"Model name:\\\", self.name)\\n print(\\\"Number of bodies:\\\", len(self.bodies))\\n print(\\\"Number of scenarios:\\\", len(self.scenarios))\\n print(\\\" \\\")\\n print(\\\"------------------\\\")\\n print(\\\"| Bodies summary |\\\")\\n print(\\\"------------------\\\")\\n for body in self.bodies:\\n print(\\\"Body:\\\", body.id, body.name)\\n print(\\\" coupling group:\\\", body.group)\\n print(\\\" transfer scheme:\\\", type(body.transfer))\\n print(\\\" shape parameteration:\\\", type(body.shape))\\n for vartype in body.variables:\\n print(' variable type:', vartype)\\n print(' number of ', vartype, ' variables:', len(body.variables[vartype]))\\n if print_level >= 0:\\n for var in body.variables[vartype]:\\n print(' variable:', var.name, ', active?', var.active,', coupled?', var.coupled)\\n print(' value and bounds:', var.value, var.lower, var.upper)\\n\\n print(\\\" \\\")\\n print(\\\"--------------------\\\")\\n print(\\\"| Scenario summary |\\\")\\n print(\\\"--------------------\\\")\\n for scenario in self.scenarios:\\n print(\\\"scenario:\\\", scenario.id, scenario.name)\\n print(\\\" coupling group:\\\", scenario.group)\\n print(\\\" steps:\\\", scenario.steps)\\n print(\\\" steady?:\\\", scenario.steady)\\n for func in scenario.functions:\\n print(' function:', func.name, ', analysis_type:', func.analysis_type)\\n print(' adjoint?', func.adjoint)\\n if not scenario.steady:\\n print(' time range', func.start, ',', func.stop)\\n print(' averaging', func.averaging)\\n\\n\\n for vartype in scenario.variables:\\n print(' variable type:', vartype)\\n print(' number of ', vartype, ' variables:', len(scenario.variables[vartype]))\\n if print_level >= 0:\\n for var in scenario.variables[vartype]:\\n print(' variable:', var.id, var.name, ', active?', var.active,', coupled?', var.coupled)\\n print(' value and bounds:', var.value, var.lower, var.upper)\",\n \"def model_architecture(self, filename=None):\\n list_summary = []\\n self.model.summary(print_fn=lambda x: list_summary.append(x))\\n summary = \\\"\\\\n\\\".join(list_summary)\\n\\n if filename:\\n with open(filename + '.txt', 'w') as f:\\n f.write(summary)\\n\\n from keras.utils import plot_model\\n plot_model(self.model, filename + '.jpg')\\n\\n return summary\",\n \"def summary(self):\\n from statsmodels.iolib.summary import Summary\\n from statsmodels.iolib.table import SimpleTable\\n model = self.model\\n title = model.__class__.__name__ + ' Model Results'\\n\\n dep_variable = 'endog'\\n if isinstance(self.model.endog, pd.DataFrame):\\n dep_variable = self.model.endog.columns[0]\\n elif isinstance(self.model.endog, pd.Series):\\n dep_variable = self.model.endog.name\\n seasonal_periods = None if self.model.seasonal is None else self.model.seasonal_periods\\n lookup = {'add': 'Additive', 'additive': 'Additive',\\n 'mul': 'Multiplicative', 'multiplicative': 'Multiplicative', None: 'None'}\\n transform = self.params['use_boxcox']\\n box_cox_transform = True if transform else False\\n box_cox_coeff = transform if isinstance(transform, str) else self.params['lamda']\\n if isinstance(box_cox_coeff, float):\\n box_cox_coeff = '{:>10.5f}'.format(box_cox_coeff)\\n top_left = [('Dep. Variable:', [dep_variable]),\\n ('Model:', [model.__class__.__name__]),\\n ('Optimized:', [str(np.any(self.optimized))]),\\n ('Trend:', [lookup[self.model.trend]]),\\n ('Seasonal:', [lookup[self.model.seasonal]]),\\n ('Seasonal Periods:', [str(seasonal_periods)]),\\n ('Box-Cox:', [str(box_cox_transform)]),\\n ('Box-Cox Coeff.:', [str(box_cox_coeff)])]\\n\\n top_right = [\\n ('No. Observations:', [str(len(self.model.endog))]),\\n ('SSE', ['{:5.3f}'.format(self.sse)]),\\n ('AIC', ['{:5.3f}'.format(self.aic)]),\\n ('BIC', ['{:5.3f}'.format(self.bic)]),\\n ('AICC', ['{:5.3f}'.format(self.aicc)]),\\n ('Date:', None),\\n ('Time:', None)]\\n\\n smry = Summary()\\n smry.add_table_2cols(self, gleft=top_left, gright=top_right,\\n title=title)\\n formatted = self.params_formatted # type: pd.DataFrame\\n\\n def _fmt(x):\\n abs_x = np.abs(x)\\n scale = 1\\n if abs_x != 0:\\n scale = int(np.log10(abs_x))\\n if scale > 4 or scale < -3:\\n return '{:>20.5g}'.format(x)\\n dec = min(7 - scale, 7)\\n fmt = '{{:>20.{0}f}}'.format(dec)\\n return fmt.format(x)\\n\\n tab = []\\n for _, vals in formatted.iterrows():\\n tab.append([_fmt(vals.iloc[1]),\\n '{0:>20}'.format(vals.iloc[0]),\\n '{0:>20}'.format(str(bool(vals.iloc[2])))])\\n params_table = SimpleTable(tab, headers=['coeff', 'code', 'optimized'],\\n title=\\\"\\\",\\n stubs=list(formatted.index))\\n\\n smry.tables.append(params_table)\\n\\n return smry\",\n \"def create_summary_and_adjust_model_for_gpus(self) -> None:\\n if self._model is None:\\n raise ValueError(\\\"Model must be created before it can be adjusted.\\\")\\n\\n if self.config.is_segmentation_model:\\n summary_for_segmentation_models(self.config, self._model)\\n # Prepare for mixed precision training and data parallelization (no-op if already done).\\n # This relies on the information generated in the model summary.\\n self.adjust_model_for_gpus()\",\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 set_up_summary_writer(model_config,\\n sess):\\n\\n paths_config = model_config.paths_config\\n\\n logdir = paths_config.logdir\\n if not os.path.exists(logdir):\\n os.makedirs(logdir)\\n\\n logdir = logdir + '/eval'\\n\\n datetime_str = str(datetime.datetime.now())\\n summary_writer = tf.summary.FileWriter(logdir + '/' + datetime_str,\\n sess.graph)\\n\\n global_summaries = set([])\\n summaries = set(tf.get_collection(tf.GraphKeys.SUMMARIES))\\n summary_merged = summary_utils.summaries_to_keep(summaries,\\n global_summaries,\\n histograms=False,\\n input_imgs=False,\\n input_bevs=False)\\n\\n return summary_writer, summary_merged\",\n \"def create_summary_writer(model, data_loader, log_dir):\\n writer = SummaryWriter(log_dir=log_dir)\\n data_loader_iter = iter(data_loader)\\n x = next(data_loader_iter)\\n try:\\n writer.add_graph(model, x)\\n except Exception as e:\\n warnings.warn(\\\"Failed to save model graph: {}\\\".format(e))\\n return writer\",\n \"def get_model_summary(self):\\n\\n summary = self._model[0].get_model_summary()\\n lower_bound = self._FLOAT_STRING_FORMAT.format(self._break_points[0])\\n upper_bound = self._FLOAT_STRING_FORMAT.format(self._break_points[1])\\n summary_title = 'Segment model range: ' \\\\\\n + lower_bound \\\\\\n + ' <= ' + self._explanatory_variables[0] \\\\\\n + ' < ' + upper_bound\\n summary.tables[0].title = summary_title\\n\\n number_of_segments = self.get_number_of_segments()\\n\\n spacer_table = SimpleTable(data=['=' * 50])\\n\\n for i in range(1, number_of_segments):\\n segment_model_summary = self._model[i].get_model_summary()\\n lower_bound = self._FLOAT_STRING_FORMAT.format(self._break_points[i])\\n upper_bound = self._FLOAT_STRING_FORMAT.format(self._break_points[i + 1])\\n summary_title = 'Segment model range: ' \\\\\\n + lower_bound \\\\\\n + ' <= ' + self._explanatory_variables[0] \\\\\\n + ' < ' + upper_bound\\n segment_model_summary.tables[0].title = summary_title\\n summary.tables.extend([spacer_table] + segment_model_summary.tables)\\n\\n return summary\",\n \"def get_model_summary(self):\\n\\n summary = Summary()\\n\\n # add the model equation with estimated parameters\\n model_equation = self._get_model_equation()\\n summary.tables.append(model_equation)\\n\\n # add the parameter summary\\n params_summary = self._get_params_summary()\\n summary.tables.append(params_summary)\\n\\n res = self._model.fit()\\n\\n # add more summary statistics\\n gleft = self._get_left_summary_table(res)\\n gright = self._get_right_summary_table(res)\\n summary.add_table_2cols(res, gleft=gleft, gright=gright)\\n\\n # add extreme influence and outlier table\\n high_leverage = ('High leverage:', self._FLOAT_STRING_FORMAT.format(3 * res.params.shape[0] / res.nobs))\\n extreme_outlier = ('Extreme outlier (Standardized residual):', self._FLOAT_STRING_FORMAT.format(3))\\n dfn = res.params.shape[0] + 1\\n dfd = res.nobs + res.params.shape[0]\\n high_influence_cooksd = (\\\"High influence (Cook's D)\\\",\\n self._FLOAT_STRING_FORMAT.format(stats.f.ppf(0.9, dfn=dfn, dfd=dfd)))\\n high_influence_dffits = (\\\"High influence (DFFITS)\\\",\\n self._FLOAT_STRING_FORMAT.format(2 * np.sqrt(res.params.shape[0] / res.nobs)))\\n influence_and_outlier_table_data = [high_leverage,\\n extreme_outlier,\\n high_influence_cooksd,\\n high_influence_dffits]\\n influence_and_outlier_table = SimpleTable(data=influence_and_outlier_table_data)\\n summary.tables.append(influence_and_outlier_table)\\n\\n return summary\",\n \"def model(self):\\n\\n # write summaries\\n\\n i = keras.Input(self.s)\\n\\n\\n return keras.Model(inputs=[i], outputs=self.call(i))\",\n \"def model(self):\\n\\n # write summaries\\n\\n i = keras.Input(self.s)\\n\\n\\n return keras.Model(inputs=[i], outputs=self.call(i))\",\n \"def summarize(self, *args, **kwargs) -> Optional[ModelSummary]:\\n summary = super().summarize(*args, **kwargs)\\n save_txt(summary, \\\"./network\\\")\\n return summary\",\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 logging_init(model, graph):\\n # Add ops to record summaries for loss and accuracy...\\n train_loss = tf.summary.scalar(\\\"train_loss\\\", model.loss)\\n train_accuracy = tf.summary.scalar(\\\"train_accuracy\\\", model.accuracy)\\n # ...then merge these ops into one single op so that they easily be run\\n # together\\n train_summary_ops = tf.summary.merge([train_loss, train_accuracy])\\n # Same ops, but with different names, so that train/test results show up\\n # separately in TensorBoard\\n test_loss = tf.summary.scalar(\\\"test_loss\\\", model.loss)\\n test_accuracy = tf.summary.scalar(\\\"test_accuracy\\\", model.accuracy)\\n test_summary_ops = tf.summary.merge([test_loss, test_accuracy])\\n\\n timestamp = int(time.time())\\n run_log_dir = os.path.join(LOGS_DIR, str(timestamp))\\n os.makedirs(run_log_dir)\\n # (this step also writes the graph to the events file so that\\n # it shows up in TensorBoard)\\n summary_writer = tf.summary.FileWriter(run_log_dir, graph)\\n\\n return train_summary_ops, test_summary_ops, summary_writer\",\n \"def summary(self):\\n return self.model.summary()\",\n \"def visualize_model(self):\\n if self.model is None:\\n print(\\\"%s.visualize: implement me\\\" % (self.__class__.__name__))\",\n \"def save(model, save_name):\\n dirs = configparser.ConfigParser()\\n dirs.read(\\\"config/dir_config.ini\\\")\\n\\n save_name = os.path.splitext(save_name)[0]\\n path = os.path.join(dirs[\\\"save_dirs\\\"][\\\"models\\\"], save_name + \\\".h5\\\")\\n info = os.path.join(dirs[\\\"save_dirs\\\"][\\\"models\\\"], save_name + \\\"_info.txt\\\")\\n\\n with open(info, \\\"w\\\") as file:\\n model.summary(print_fn=lambda x: file.write(f\\\"{x}\\\\n\\\"))\\n model.save(path, overwrite=False)\",\n \"def print_model_status(model):\\n\\tstatus = model.status\\n\\tif status == 2:\\n\\t\\tgrb_message = 'Model solved to optimality'\\n\\tif status == 8:\\n\\t\\tgrb_message = 'Model hits node limit'\\n\\tif status == 9:\\n\\t\\tgrb_message = 'Model hits time limit'\\n\\ttry:\\n\\t\\tprint grb_message\\n\\texcept NameError:\\n\\t\\tprint 'unknown model exist status code: {}'.format(status)\",\n \"def save_model(model, save_folder_path, model_name, model_ext):\\n\\n \\n assert model_ext in [\\\".h5\\\", \\\".hdf5\\\"]\\n assert os.path.isdir(save_folder_path)==True, \\\"model_folder_path is not a folder.\\\"\\n\\n print(\\\"[INFO] Saving model to {0}/\\\".format(save_folder_path))\\n model_path = \\\"{}/{}\\\".format(save_folder_path, model_name + model_ext)\\n model.save(model_path)\\n\\n with open('{}/{}'.format(save_folder_path, \\\"model_summary.txt\\\"), 'w') as f:\\n with redirect_stdout(f):\\n model.summary()\\n \\n # visualize model architecture\\n plot_model(model, to_file=\\\"{}/{}.png\\\".format(save_folder_path, model_name),\\n show_shapes=True)\",\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_model_generation(model):\\n print('g1 = {} MW'.format(model.g[1].value))\\n print('g2 = {} MW'.format(model.g[2].value))\",\n \"def torch_summarize(model, show_weights=True, show_parameters=True):\\n tmpstr = model.__class__.__name__ + ' (\\\\n'\\n for key, module in model._modules.items():\\n # if it contains layers let call it recursively to get params and weights\\n if type(module) in [\\n torch.nn.modules.container.Container,\\n torch.nn.modules.container.Sequential\\n ]:\\n modstr = torch_summarize(module)\\n else:\\n modstr = module.__repr__()\\n modstr = _addindent(modstr, 2)\\n\\n params = sum([np.prod(p.size()) for p in module.parameters()])\\n weights = tuple([tuple(p.size()) for p in module.parameters()])\\n\\n tmpstr += ' (' + key + '): ' + modstr \\n if show_weights:\\n tmpstr += ', weights={}'.format(weights)\\n if show_parameters:\\n tmpstr += ', parameters={}'.format(params)\\n tmpstr += '\\\\n' \\n\\n tmpstr = tmpstr + ')'\\n return tmpstr\",\n \"def get_summary(self):\\n return self.model.summary()\",\n \"def test_get_summary_with_new_model(self):\\n\\t\\t\\n\\t\\tnew_model = models.vgg13(weights='VGG13_Weights.IMAGENET1K_V1').state_dict()\\n\\t\\tdescription = self.watcher.describe(model=new_model)\\n\\t\\tself.assertEqual(13, len(description))\\n\\t\\t\\n\\t\\tfc3_layer = description.layer_id.to_numpy()[-1]\\n\\t\\tdetails = self.watcher.analyze(model=new_model, layers=fc3_layer)\\n\\t\\treturned_summary = self.watcher.get_summary(details)\\n\\t\\t\\n\\t\\tprint(returned_summary)\\n\\t\\t\\n\\t\\tsaved_summary = self.watcher.get_summary()\\n\\t\\tself.assertEqual(returned_summary, saved_summary)\",\n \"def torch_summarize(model, show_weights=True, show_parameters=True):\\n\\n tmpstr = model.__class__.__name__ + ' (\\\\n'\\n for key, module in model._modules.items():\\n # if it contains layers let call it recursively to get params and\\n # weights\\n if type(module) in [\\n torch.nn.modules.container.Container,\\n torch.nn.modules.container.Sequential\\n ]:\\n modstr = torch_summarize(module)\\n else:\\n modstr = module.__repr__()\\n modstr = _addindent(modstr, 2)\\n\\n params = sum([np.prod(p.size()) for p in module.parameters()])\\n weights = tuple([tuple(p.size()) for p in module.parameters()])\\n\\n tmpstr += ' (' + key + '): ' + modstr\\n if show_weights:\\n tmpstr += ', weights={}'.format(weights)\\n if show_parameters:\\n tmpstr += ', parameters={}'.format(params)\\n tmpstr += '\\\\n'\\n\\n tmpstr = tmpstr + ')'\\n return tmpstr\",\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 produce_summary_pdf(model_name, img_path, hyperparams, model_arch, train_stats):\\n # datetime object containing current date and time\\n now = datetime.now()\\n dt_string = now.strftime(\\\"%d/%m/%Y %H:%M:%S\\\")\\n\\n pdf = FPDF()\\n pdf.set_title(\\\"training_summary_{}_{}\\\".format(model_name.lower(), dt_string))\\n pdf.add_page()\\n pdf.set_xy(0, 10)\\n pdf.set_font(\\\"Helvetica\\\", \\\"BI\\\", 16)\\n pdf.set_text_color(25, 33, 78)\\n pdf.set_draw_color(25, 33, 78)\\n pdf.cell(20)\\n pdf.cell(\\n 200,\\n 10,\\n \\\"Model Training Summary: {}\\\".format(model_name.upper()),\\n 0,\\n 2,\\n )\\n pdf.set_font(\\\"Helvetica\\\", \\\"B\\\", 12)\\n pdf.cell(\\n 200,\\n 5,\\n dt_string,\\n 0,\\n 2,\\n )\\n\\n # Model Configuration Section\\n pdf.cell(150, 10, \\\"Model Configuration:\\\", 0, 2)\\n pdf.cell(30, 10, \\\"Parameter\\\", 1, 0)\\n pdf.cell(140, 10, \\\"Value\\\", 1, 2)\\n pdf.set_text_color(255, 96, 80)\\n pdf.set_font(\\\"Helvetica\\\", \\\"\\\", 12)\\n pdf.cell(-30)\\n attributes = [\\n \\\"model_dir\\\",\\n \\\"log_dir\\\",\\n \\\"check_dir\\\",\\n \\\"current_epoch\\\",\\n \\\"overwrite\\\",\\n \\\"exp_name\\\",\\n ]\\n for i, val in enumerate(hyperparams):\\n if val not in attributes:\\n pdf.cell(30, 10, \\\"%s\\\" % (val), 1, 0)\\n pdf.cell(140, 10, \\\"%s\\\" % (hyperparams[val]), 1, 2)\\n pdf.cell(-30)\\n pdf.cell(90, 3, \\\"\\\", 0, 2)\\n\\n # Model Performance Section\\n pdf.set_text_color(25, 33, 78)\\n pdf.set_font(\\\"Helvetica\\\", \\\"B\\\", 12)\\n pdf.cell(150, 10, \\\"Model Performance Stats:\\\", 0, 2)\\n pdf.set_font(\\\"Helvetica\\\", \\\"\\\", 12)\\n\\n loss = train_stats[\\\"test_loss\\\"]\\n acc = train_stats[\\\"test_acc\\\"]\\n\\n pdf.set_text_color(255, 96, 80)\\n pdf.cell(35, 6, \\\"Best Loss:\\\", 0, 0)\\n pdf.cell(\\n 45, 6, \\\"{:.3f} (Epoch {})\\\".format(min(loss), loss.index(min(loss)) + 1), 0, 0\\n )\\n pdf.cell(60, 6, \\\"Training Duration:\\\", 0, 0)\\n pdf.cell(30, 6, \\\"{:.3f} (s)\\\".format(train_stats[\\\"total_dur\\\"]), 0, 2)\\n pdf.cell(-140)\\n pdf.cell(35, 6, f\\\"Best Accuracy:\\\", 0, 0)\\n pdf.cell(45, 6, \\\"{:.3f} (Epoch {})\\\".format(max(acc), acc.index(max(acc)) + 1), 0, 0)\\n pdf.cell(60, 6, \\\"Average Epoch Duration:\\\", 0, 0)\\n pdf.cell(\\n 30,\\n 6,\\n \\\"{:.3f} (s)\\\".format(train_stats[\\\"total_dur\\\"] / hyperparams[\\\"current_epoch\\\"]),\\n 0,\\n 2,\\n )\\n pdf.cell(-140)\\n pdf.cell(90, 3, \\\"\\\", 0, 2)\\n\\n # Loss Curve Section\\n pdf.set_text_color(25, 33, 78)\\n pdf.set_font(\\\"Helvetica\\\", \\\"B\\\", 12)\\n pdf.cell(150, 10, \\\"Model Loss Curve:\\\", 0, 2)\\n pdf.image(img_path, x=None, y=None, w=160, h=0, type=\\\"PNG\\\", link=\\\"\\\")\\n\\n # Second Page of Report\\n pdf.add_page()\\n pdf.set_xy(0, 0)\\n pdf.cell(20, 20)\\n\\n # Model Arch Section\\n pdf.cell(150, 20, \\\"Model Configuration:\\\", 0, 2)\\n pdf.set_font(\\\"Helvetica\\\", \\\"\\\", 12)\\n if model_arch is None:\\n model_arch = \\\"No model configuration was provided\\\"\\n pdf.set_text_color(255, 96, 80)\\n pdf.multi_cell(180, 8, str(model_arch))\\n\\n # Third Page of Report\\n pdf.add_page()\\n pdf.set_xy(0, 0)\\n pdf.cell(20, 20, \\\" \\\")\\n\\n # Training Loss Section\\n pdf.set_text_color(25, 33, 78)\\n pdf.set_font(\\\"Helvetica\\\", \\\"B\\\", 12)\\n pdf.cell(150, 20, \\\"Detailed Loss Output:\\\", 0, 2)\\n pdf.cell(40, 8, \\\"Epoch\\\", 1, 0, \\\"C\\\")\\n pdf.cell(30, 8, \\\"Train Loss\\\", 1, 0, \\\"C\\\")\\n pdf.cell(30, 8, \\\"Test Loss\\\", 1, 0, \\\"C\\\")\\n pdf.cell(30, 8, \\\"Train Acc\\\", 1, 0, \\\"C\\\")\\n pdf.cell(30, 8, \\\"Test Acc\\\", 1, 2, \\\"C\\\")\\n pdf.set_text_color(255, 96, 80)\\n pdf.set_font(\\\"Helvetica\\\", \\\"\\\", 12)\\n pdf.cell(-130)\\n for i in range(0, len(train_stats[\\\"train_loss\\\"])):\\n pdf.cell(40, 8, \\\"{}\\\".format((i + 1)), 1, 0, \\\"C\\\")\\n pdf.cell(30, 8, \\\"{:.3f}\\\".format((train_stats[\\\"train_loss\\\"][i])), 1, 0, \\\"C\\\")\\n pdf.cell(30, 8, \\\"{:.3f}\\\".format((train_stats[\\\"test_loss\\\"][i])), 1, 0, \\\"C\\\")\\n pdf.cell(30, 8, \\\"{:.3f}\\\".format((train_stats[\\\"train_acc\\\"][i])), 1, 0, \\\"C\\\")\\n pdf.cell(30, 8, \\\"{:.3f}\\\".format((train_stats[\\\"test_acc\\\"][i])), 1, 2, \\\"C\\\")\\n pdf.cell(-130)\\n pdf.cell(90, 3, \\\"\\\", 0, 2)\\n\\n pdf.output(\\n os.path.join(\\n os.path.dirname(img_path),\\n \\\"training_summary_{}.pdf\\\".format(model_name.lower()),\\n ),\\n \\\"F\\\",\\n )\",\n \"def LogProgress(model, writer, test_loader, epoch, device): \\n\\n model.eval() \\n sequential = test_loader\\n sample_batched = next(iter(sequential))\\n \\n image = torch.Tensor(sample_batched[\\\"image\\\"]).to(device)\\n depth = torch.Tensor(sample_batched[\\\"depth\\\"]).to(device)\\n \\n if epoch == 0:\\n writer.add_image(\\\"Train.1.Image\\\", vision_utils.make_grid(image.data, nrow=6, normalize=True), epoch)\\n if epoch == 0:\\n writer.add_image(\\\"Train.2.Image\\\", colorize(vision_utils.make_grid(depth.data, nrow=6, normalize=False)), epoch)\\n \\n output = DepthNorm(model(image))\\n\\n writer.add_image(\\\"Train.3.Ours\\\", colorize(vision_utils.make_grid(output.data, nrow=6, normalize=False)), epoch)\\n writer.add_image(\\\"Train.4.Diff\\\", colorize(vision_utils.make_grid(torch.abs(output-depth).data, nrow=6, normalize=False)), epoch)\\n \\n del image\\n del depth\\n del output\",\n \"def print_info(self):\\r\\n self.system.print_to_log(\\r\\n f\\\"{self.__class__.__name__} model: Infection probability: {self.p}, Infectious period: {self.i}, Recovery period: {self.r}.\\\")\",\n \"def summary(self, test_type='t-test'):\\n summary = f'Results for running {self.cv_method} evaluation for {self.method} '\\n summary += f'on {self.n_model} models:\\\\n\\\\n'\\n name_length = max([max(len(m.name) for m in self.models) + 1, 6])\\n means = self.get_means()\\n sems = self.get_sem()\\n if means is None:\\n means = np.nan * np.ones(self.n_model)\\n if sems is None:\\n sems = np.nan * np.ones(self.n_model)\\n try:\\n p_zero = self.test_zero(test_type=test_type)\\n p_noise = self.test_noise(test_type=test_type)\\n except ValueError:\\n p_zero = np.nan * np.ones(self.n_model)\\n p_noise = np.nan * np.ones(self.n_model)\\n # header of the results table\\n summary += 'Model' + (' ' * (name_length - 5))\\n summary += '| Eval \\\\u00B1 SEM |'\\n summary += ' p (against 0) |'\\n summary += ' p (against NC) |\\\\n'\\n summary += '-' * (name_length + 51)\\n summary += '\\\\n'\\n for i, m in enumerate(self.models):\\n summary += m.name + (' ' * (name_length - len(m.name)))\\n summary += f'| {means[i]: 5.3f} \\\\u00B1 {sems[i]:4.3f} |'\\n if p_zero[i] < 0.001:\\n summary += ' < 0.001 |'\\n else:\\n summary += f'{p_zero[i]:>13.3f} |'\\n if p_noise[i] < 0.001:\\n summary += ' < 0.001 |'\\n else:\\n summary += f'{p_noise[i]:>14.3f} |'\\n summary += '\\\\n'\\n summary += '\\\\n'\\n if self.cv_method == 'crossvalidation':\\n summary += 'No p-values available as crossvalidation provides no variance estimate'\\n elif test_type == 't-test':\\n summary += 'p-values are based on uncorrected t-tests'\\n elif test_type == 'bootstrap':\\n summary += 'p-values are based on percentiles of the bootstrap samples'\\n elif test_type == 'ranksum':\\n summary += 'p-values are based on ranksum tests'\\n return summary\",\n \"def print_model_description(verbose: bool):\\n\\n desc = get_model_description()\\n description = f\\\"\\\"\\\"\\nModel ID: {desc['id']}\\nRelease Date: {desc['releaseDate']}\\nCavity Labels: {desc['cavityLabels']}\\nFault Labels: {desc['faultLabels']}\\nTraining Data: {desc['trainingData']}\\nBrief: {desc['brief']}\\n\\\"\\\"\\\"\\n if verbose:\\n description += os.linesep + f\\\"Details: {desc['details']}\\\"\\n print(description)\",\n \"def torch_summarize(model, show_weights=True, show_parameters=True):\\n tmpstr = model.__class__.__name__ + ' (\\\\n'\\n for key, module in model._modules.items():\\n # if it contains layers let call it recursively to get params and weights\\n if type(module) in [\\n torch.nn.modules.container.Container,\\n torch.nn.modules.container.Sequential\\n ]:\\n modstr = torch_summarize(module)\\n else:\\n modstr = module.__repr__()\\n modstr = _addindent(modstr, 2)\\n\\n params = sum([np.prod(p.size()) for p in module.parameters()])\\n weights = tuple([tuple(p.size()) for p in module.parameters()])\\n\\n tmpstr += ' (' + key + '): ' + modstr\\n if show_weights:\\n tmpstr += ', weights={}'.format(weights)\\n if show_parameters:\\n tmpstr += ', parameters={}'.format(params)\\n tmpstr += '\\\\n'\\n\\n tmpstr = tmpstr + ')'\\n return tmpstr\",\n \"def log_model(self, model_name=\\\"fixmatch_model\\\"):\\n \\n assert hasattr(self, \\\"_mlflow\\\"), \\\"need to run track_with_mlflow() first\\\"\\n from mlflow.keras import log_model\\n log_model(self._models[\\\"full\\\"], model_name)\",\n \"def create_log(self):\\n self.model.graph.get_stats()\\n out = self.model.graph.summary\\n out[\\\"training_error\\\"] = zip(self.train_it, self.train_err)\\n out[\\\"validation_error\\\"] = zip(self.validation_it, self.validation_err)\\n with open(self.log, \\\"w\\\") as f:\\n f.write(json.dumps(out, default=defaultencode))\",\n \"def save_arch(model, save_folder):\\n with open(save_folder + '/architecture.txt','w') as a_save:\\n model.summary(print_fn=lambda x: a_save.write(x + '\\\\n'))\",\n \"def print_summary(self):\\n self.network.print_summary()\",\n \"def Plot_model_diagram(model, save= True):\\n if save:\\n keras.utils.plot_model(model, to_file= \\\"images/CNN_SE_model.png\\\")\\n else:\\n keras.utils.plot_model(model)\",\n \"def summary_info(self):\\n return [('model_architecture', self.model_architecture),\\n ('input_size', self.input_size),\\n ('output_size', self.output_size),\\n ('hidden_layers', self.hidden_layers),\\n ('learn_rate', self.learn_rate),\\n ('drop_p', self.drop_p),\\n ('current_epoch', self.model.current_epoch)]\",\n \"def visualize_model(model=None, filename=\\\"InceptionV3_visualization.png\\\"):\\n if model is None:\\n p_model = InceptionV3(weights='imagenet', include_top=False)\\n else:\\n p_model = model\\n keras.utils.plot_model(p_model, to_file=filename)\",\n \"def add_summary(self):\\n merged = tf.summary.merge_all()\\n self.file_writer = tf.summary.FileWriter(self.FLAGS.model_dir, self.session.graph)\",\n \"def ols_summary(output_dir: str, model: OLSModel,\\n tree: TreeNode) -> None:\\n warnings.warn(\\\"This visualization are deprecated.\\\", DeprecationWarning)\\n # Cross validation\\n w, h = 500, 300 # plot width and height\\n\\n # Explained sum of squares\\n ess = model.ess\\n # Summary object\\n _k, _l = model.kfold(), model.lovo()\\n smry = model.summary(_k, _l)\\n _deposit_results(model, output_dir)\\n t = _decorate_tree(tree, ess)\\n\\n p1 = radialplot(t, figsize=(800, 800))\\n p1.title.text = 'Explained Sum of Squares'\\n p1.title_location = 'above'\\n p1.title.align = 'center'\\n p1.title.text_font_size = '18pt'\\n\\n # 2D scatter plot for prediction on PB\\n p2 = _projected_prediction(model, plot_width=w, plot_height=h)\\n p3 = _projected_residuals(model, plot_width=w, plot_height=h)\\n hm_p = _heatmap_summary(model.pvalues.T, model.coefficients().T)\\n\\n # combine the cross validation, explained sum of squares tree and\\n # residual plots into a single plot\\n p = row(column(p2, p3), p1)\\n p = column(hm_p, p)\\n index_fp = os.path.join(output_dir, 'index.html')\\n with open(index_fp, 'w') as index_f:\\n index_f.write('<html><body>\\\\n')\\n index_f.write('<h1>Simplicial Linear Regression Summary</h1>\\\\n')\\n index_f.write(smry.as_html())\\n index_f.write(\\n ('<th>Coefficients</th>\\\\n'\\n '<a href=\\\"coefficients.csv\\\">'\\n 'Download as CSV</a><br>\\\\n'\\n '<th>Coefficient pvalues</th>\\\\n'\\n '<a href=\\\"pvalues.csv\\\">'\\n 'Download as CSV</a><br>\\\\n'\\n '<th>FDR corrected coefficient pvalues</th>\\\\n'\\n '<a href=\\\"fdr-corrected-pvalues.csv\\\">'\\n 'Download as CSV</a><br>\\\\n'\\n '<th>Predicted Balances</th>\\\\n'\\n '<a href=\\\"predicted.csv\\\">'\\n 'Download as CSV</a><br>\\\\n'\\n '<th>Residuals</th>\\\\n'\\n '<a href=\\\"residuals.csv\\\">'\\n 'Download as CSV</a><br>\\\\n')\\n )\\n\\n plot_html = file_html(p, CDN, 'Diagnostics')\\n index_f.write(plot_html)\\n index_f.write('</body></html>\\\\n')\",\n \"def summary(self):\\n if self.model_type == 2:\\n if self.std is None:\\n print(\\n dedent(\\n f\\\"\\\"\\\"\\\\\\n Oaxaca-Blinder Two-fold Effects\\n Unexplained Effect: {self.params[0]:.5f}\\n Explained Effect: {self.params[1]:.5f}\\n Gap: {self.params[2]:.5f}\\\"\\\"\\\"\\n )\\n )\\n else:\\n print(\\n dedent(\\n \\\"\\\"\\\"\\\\\\n Oaxaca-Blinder Two-fold Effects\\n Unexplained Effect: {:.5f}\\n Unexplained Standard Error: {:.5f}\\n Explained Effect: {:.5f}\\n Explained Standard Error: {:.5f}\\n Gap: {:.5f}\\\"\\\"\\\".format(\\n self.params[0],\\n self.std[0],\\n self.params[1],\\n self.std[1],\\n self.params[2],\\n )\\n )\\n )\\n if self.model_type == 3:\\n if self.std is None:\\n print(\\n dedent(\\n f\\\"\\\"\\\"\\\\\\n Oaxaca-Blinder Three-fold Effects\\n Endowment Effect: {self.params[0]:.5f}\\n Coefficient Effect: {self.params[1]:.5f}\\n Interaction Effect: {self.params[2]:.5f}\\n Gap: {self.params[3]:.5f}\\\"\\\"\\\"\\n )\\n )\\n else:\\n print(\\n dedent(\\n f\\\"\\\"\\\"\\\\\\n Oaxaca-Blinder Three-fold Effects\\n Endowment Effect: {self.params[0]:.5f}\\n Endowment Standard Error: {self.std[0]:.5f}\\n Coefficient Effect: {self.params[1]:.5f}\\n Coefficient Standard Error: {self.std[1]:.5f}\\n Interaction Effect: {self.params[2]:.5f}\\n Interaction Standard Error: {self.std[2]:.5f}\\n Gap: {self.params[3]:.5f}\\\"\\\"\\\"\\n )\\n )\",\n \"def printModel(self, model):\\n print(\\\"[L DIAG] startLoop =\\\", model.evaluate(self.startLoop))\\n print(\\\"[L DIAG] endLoop =\\\", model.evaluate(self.endLoop))\\n print(\\\"[L DIAG] projStartStateFaulty =\\\", model.evaluate(self.projStartStateFaulty))\\n print(\\\"[L DIAG] projEndStateFaulty =\\\", model.evaluate(self.projEndStateFaulty))\\n print(\\\"[L DIAG] projStartStateNormal =\\\", model.evaluate(self.projStartStateNormal))\\n print(\\\"[L DIAG] projEndStateNormal =\\\", model.evaluate(self.projEndStateNormal))\\n\\n print(\\\"[L DIAG] stateFaultyPath: \\\")\\n self.printOneIntArray(model, self.stateFaultyPath)\\n print(\\\"[L DIAG] stateNormalPath: \\\")\\n self.printOneIntArray(model, self.stateNormalPath)\\n\\n print()\\n super().printModel(model)\",\n \"def save_architecture(model, path_out):\\n # Redirect the print output the a textfile\\n orig_stdout = sys.stdout\\n # and store the architecture\\n f = file(os.path.join(path_out, \\\"architecture.txt\\\"), 'w')\\n sys.stdout = f\\n model.summary()\\n # Reset the print output direction\\n sys.stdout = orig_stdout\\n f.close()\\n\\n open(os.path.join(path_out, \\\"config.json\\\"), 'w').write(model.to_json())\",\n \"def test_get_summary_no_model(self):\\n\\t\\t\\n\\t\\tdescription = self.watcher.describe(model=self.model)\\n\\t\\tself.assertEqual(11, len(description))\\n\\t\\t\\n\\t\\t\\n\\t\\tdetails = self.watcher.analyze(model=self.model, layers=[self.fc2_layer])\\n\\t\\treturned_summary = self.watcher.get_summary(details)\\n\\t\\t\\n\\t\\tprint(returned_summary)\\n\\t\\t\\n\\t\\tsaved_summary = self.watcher.get_summary()\\n\\t\\tself.assertEqual(returned_summary, saved_summary)\",\n \"def info(model: str = None) -> dict:\\n model_instance = get_model(model)\\n log.debug(\\\"Get info for \\\" + str(model_instance))\\n return model_instance.info()\",\n \"def save_model(self):\\n\\n print('Save model')\\n self.feature_extractor.save_weights(\\n self.path_save_model + self.name_model + '.h5')\\n\\n print('Mean and std')\\n np.save(self.path_save_model + 'mean.npy', self.mean)\\n np.save(self.path_save_model + 'std.npy', self.std)\",\n \"def save_model(model):\\n # ***\\n # Please remove the comment to enable model save.\\n # However, it will overwrite the baseline model we provided.\\n # ***\\n model.save(\\\"model/model.h5\\\")\\n print(\\\"Model Saved Successfully.\\\")\",\n \"def dispPowerSum(model):\\n print(\\\"*** System Power Overview ***\\\")\\n print(\\\"Pm:\\\\t%.3f\\\" % model.ss_Pm)\\n print(\\\"Pe:\\\\t%.3f\\\" % model.ss_Pe)\\n print(\\\"Pacc:\\\\t%.3f\\\" % model.ss_Pacc)\\n print(\\\"Pload:\\\\t%.3f\\\" % model.ss_Pload)\\n print(\\\"Ploss:\\\\t%.3f\\\" % model.PLosses)\\n print(\\\"*_*\\\")\\n #NOTE: Q values are meaningless until Shunts and SVDs are accounted for\\n print(\\\"Qgen:\\\\t%.3f\\\" % model.ss_Qgen)\\n print(\\\"Qload:\\\\t%.3f\\\" % model.ss_Qload)\\n print(\\\"Qloss:\\\\t%.3f\\\" % model.QLosses)\\n print(\\\"***_______________________***\\\")\",\n \"def model_info(model):\\n return juju.CLIENT.Client(request=\\\"ModelInfo\\\",\\n params={\\\"Name\\\": model})\",\n \"def execute_summary(self, step):\\n with self.summary_writer.as_default():\\n tf.summary.scalar('bias', self.core.fmlayer.b, step=step)\\n tf.summary.scalar('regularization_penalty', self.regularization, step=step)\\n tf.summary.scalar('loss', self.reduced_loss, step=step)\\n tf.summary.scalar('target', self.target, step=step)\",\n \"def define_model(model):\\n global log_data_likelihood, log_priors, num_params, file_labels, labels, prior_xs, prior_pdfs\\n num_prior_pts = 1001\\n pic50_lower = -4.\\n pic50_upper = 14.\\n hill_lower = 0.\\n hill_upper = 6.\\n if model == 1:\\n num_params = 2\\n log_data_likelihood = log_data_likelihood_model_1_capped\\n log_priors = log_priors_model_1\\n labels = [r\\\"$pIC50$\\\", r\\\"$\\\\sigma$\\\"]\\n file_labels = ['pIC50','sigma']\\n #prior_xs = [np.linspace(pic50_lower, pic50_upper, num_prior_pts),\\n # np.linspace(sigma_uniform_lower,sigma_uniform_upper,num_prior_pts)]\\n prior_xs = [np.linspace(pic50_exp_lower-2, pic50_exp_lower+23, num_prior_pts),\\n np.linspace(0, 25, num_prior_pts)]\\n #prior_pdfs = [st.logistic.pdf(prior_xs[0], loc=mu, scale=s),\\n # np.ones(num_prior_pts)/(1.*sigma_uniform_upper-sigma_uniform_lower)]\\n #prior_pdfs = [st.expon.pdf(prior_xs[0], loc=pic50_exp_lower, scale=pic50_exp_scale),\\n # np.concatenate(([0,0],np.ones(num_prior_pts)/(1.*sigma_uniform_upper-sigma_uniform_lower),[0,0]))]\\n prior_pdfs = [st.expon.pdf(prior_xs[0], loc=pic50_exp_lower, scale=pic50_exp_scale),\\n st.gamma.pdf(prior_xs[1], sigma_shape, loc=sigma_loc, scale=sigma_scale)]\\n elif model == 2:\\n num_params = 3\\n log_data_likelihood = log_data_likelihood_model_2_capped\\n log_priors = log_priors_model_2\\n labels = [r\\\"$pIC50$\\\", r\\\"$Hill$\\\", r\\\"$\\\\sigma$\\\"]\\n file_labels = ['pIC50','Hill','sigma']\\n #prior_xs = [np.linspace(pic50_lower, pic50_upper, num_prior_pts),\\n # np.linspace(hill_lower, hill_upper, num_prior_pts),\\n # np.linspace(sigma_uniform_lower,sigma_uniform_upper,num_prior_pts)]\\n prior_xs = [np.linspace(pic50_exp_lower-2, pic50_exp_lower+23, num_prior_pts),\\n np.concatenate(([hill_uniform_lower-2,hill_uniform_lower],\\n np.linspace(hill_uniform_lower, hill_uniform_upper, num_prior_pts),\\n [hill_uniform_upper,hill_uniform_upper+2])),\\n np.linspace(0, 25, num_prior_pts)]\\n #prior_pdfs = [st.logistic.pdf(prior_xs[0],loc=mu,scale=s),\\n # st.fisk.pdf(prior_xs[1],c=beta,scale=alpha),\\n # np.ones(num_prior_pts)/(1.*sigma_uniform_upper-sigma_uniform_lower)]\\n #prior_pdfs = [st.expon.pdf(prior_xs[0], loc=pic50_exp_lower, scale=pic50_exp_scale),\\n # np.concatenate(([0,0],np.ones(num_prior_pts) / (1. * hill_uniform_upper - hill_uniform_lower),[0,0])),\\n # np.concatenate(([0, 0], np.ones(num_prior_pts) / (1. * sigma_uniform_upper - sigma_uniform_lower), [0, 0]))]\\n prior_pdfs = [st.expon.pdf(prior_xs[0], loc=pic50_exp_lower, scale=pic50_exp_scale),\\n np.concatenate(([0,0],np.ones(num_prior_pts) / (1. * hill_uniform_upper - hill_uniform_lower),[0,0])),\\n st.gamma.pdf(prior_xs[2], sigma_shape, loc=sigma_loc, scale=sigma_scale)]\",\n \"def get_summary_model(processed_text, model_type, number_topics):\\n\\n if model_type == 'LDA':\\n count_model = CountVectorizer(ngram_range=(1, 1)).fit(processed_text)\\n return count_model, LDA(n_components=number_topics, learning_method='batch').fit(count_model.fit_transform(processed_text))\\n if model_type == 'LSA':\\n tf_idf_model = TfidfVectorizer(ngram_range=(1, 1)).fit(processed_text)\\n return tf_idf_model, TruncatedSVD(n_components=number_topics, algorithm='randomized', n_iter=100, random_state=122).fit(tf_idf_model.transform(processed_text))\\n else:\\n tf_idf_model = TfidfVectorizer(ngram_range=(1, 1)).fit(processed_text)\\n return tf_idf_model, NMF(n_components=number_topics, init='random', random_state=0).fit(tf_idf_model.transform(processed_text))\",\n \"def model_analysis(self, model_name: str, history) -> None:\\n # probabilites\\n y_pred_prob = self.recognizer.predict(self.X_test)\\n # most likely class\\n y_pred = np.argmax(y_pred_prob, axis=1)\\n # compare true and predicted classes on test set\\n\\n # path handling for writing to file\\n output_dir = Path(os.environ[\\\"MODEL_DATA\\\"]) / model_name\\n out_name = \\\"classification_report.txt\\\"\\n out_path = output_dir / out_name\\n\\n acc = history.history[\\\"accuracy\\\"]\\n val_acc = history.history[\\\"val_accuracy\\\"]\\n loss = history.history[\\\"loss\\\"]\\n val_loss = history.history[\\\"val_loss\\\"]\\n\\n epochs = range(1, len(acc) + 1)\\n\\n # plot accuracies and losses with respect to epochs\\n plt.plot(epochs, acc, \\\"r\\\", label=\\\"Train accuracy\\\")\\n plt.plot(epochs, val_acc, \\\"b\\\", label=\\\"Val accuracy\\\")\\n\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Accuracy\\\")\\n plt.legend()\\n\\n plt.savefig(output_dir / \\\"acc-plot\\\")\\n\\n plt.figure()\\n plt.plot(epochs, loss, \\\"r\\\", label=\\\"Training loss\\\")\\n plt.plot(epochs, val_loss, \\\"b\\\", label=\\\"Val loss\\\")\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Loss\\\")\\n plt.legend()\\n\\n plt.savefig(output_dir / \\\"loss-plot\\\")\\n\\n # create, print and write to file a sklearn classification report\\n print(set(self.y_test) - set(y_pred))\\n report = classification_report(self.y_test, y_pred)\\n print(report)\\n with open(out_path, \\\"w\\\") as f:\\n f.write(report)\\n\\n self.make_heatmap(y_pred, output_dir)\",\n \"def get_summary_from_model(text, model_type, number_words, target_percentage, nlp):\\n\\n # get sentences from text\\n sentences = [sentence for sentence in\\n text.lower().replace('!', '.').replace('?', '.').split('.')]\\n\\n # this pre-processing removes junk characters, and converts all sentence-ending characters to full-stops, for the\\n # purpose of splitting the text into sentences\\n processed_text = [convert_to_string(\\n lemmatize(convert_to_string(remove_non_words(remove_stop_words(tokenize_text(sentence, nlp)))), nlp)) for\\n sentence in sentences]\\n\\n # begin generating topics from the text, beginning with 1 topic\\n number_topics = 1\\n nlp_model, summary_model = get_summary_model(processed_text, model_type, number_topics)\\n topic_sentences = get_topics(summary_model, nlp_model, number_words)\\n percentage = len('. '.join(full_summarizer_word_comparison(sentences, topic_sentences, number_topics))) / len(text)\\n\\n # check if the ratio of the summary to the text is below the user-defined threshold\\n while percentage < target_percentage:\\n number_topics += 1\\n nlp_model, summary_model = get_summary_model(processed_text, model_type, number_topics)\\n topic_sentences = get_topics(summary_model, nlp_model, number_words)\\n percentage = len('. '.join(full_summarizer_word_comparison(sentences, topic_sentences, number_topics))) / len(text)\\n\\n return '. '.join(full_summarizer_word_comparison(sentences, topic_sentences, number_topics))\",\n \"def save_information(self, path: utils.URLPath):\\n # Text summary of model\\n with (path / \\\"model_summary.txt\\\").open(\\\"w\\\") as summary_file:\\n def print_file(*args, **kwargs):\\n print(*args, **kwargs, file=summary_file)\\n self.model.summary(print_fn=print_file)\\n\\n # Image plotting structure of model\\n keras.utils.plot_model(self.model, to_file=str(path / \\\"model_plot.png\\\"))\\n\\n # plot all training history\\n for i, (meta, history) in enumerate(self.training_history):\\n training_output = path / f\\\"train_{i}\\\"\\n io_functions.save_json(meta, training_output / \\\"info.json\\\")\\n plot_training_history(history, training_output / \\\"training.png\\\")\",\n \"def dump_model(self):\",\n \"def _setup_summaries(self, sess):\\n # Output directory for models and summaries\\n\\n\\n print(\\\"Writing to {}\\\\n\\\".format(os.path.abspath(self._log_dir)))\\n\\n train_summary_dir = os.path.join(self._log_dir, \\\"summaries\\\", \\\"train\\\")\\n self._train_summary_writer = tf.summary.FileWriter(train_summary_dir, sess.graph)\\n\\n val_summary_dir = os.path.join(self._log_dir, \\\"summaries\\\", \\\"validation\\\")\\n self._val_summary_writer = tf.summary.FileWriter(val_summary_dir, sess.graph)\\n\\n # Model checkpoints\\n # Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it\\n self.checkpoint_dir = os.path.abspath(os.path.join(self._save_dir, \\\"checkpoints/\\\"))\\n\\n if not os.path.exists(self.checkpoint_dir):\\n os.makedirs(self.checkpoint_dir)\\n\\n self._saver = tf.train.Saver(max_to_keep=10) # Save model after each epoch\\n\\n self.train_summary_op = tf.summary.merge(self._train_summaries)\\n self.val_summary_op = tf.summary.merge(self._val_summaries)\\n\\n print(\\\"--------------------------------------------------\\\")\\n print(\\\"\\\\ntensorboard --logdir {}\\\".format(os.path.abspath(self._log_dir)))\\n print(\\\"\\\\ntensorboard --logdir {} --port 6007\\\".format(os.path.abspath(self.checkpoint_dir)))\\n print(\\\"--------------------------------------------------\\\")\",\n \"def printModelAndTime(self):\\n import time\\n self._reporter.writeOutput(\\\"Model name = \\\" + self.modelName + '\\\\n' +\\n \\\"Output directory = \\\" + self._outputDir_ + '\\\\n' +\\n \\\"Time = \\\" + time.asctime() + '\\\\n')\\n return\",\n \"def generate_im(self, model):\\n kappa = kappy.KappaStd()\\n model_str = export.export(model, 'kappa')\\n kappa.add_model_string(model_str)\\n kappa.project_parse()\\n imap = kappa.analyses_influence_map(accuracy='medium')\\n graph = im_json_to_graph(imap)\\n return graph\",\n \"def _publish_model(self):\\n # Check if already published\\n if self.model_published:\\n return\\n\\n # Trace CPO model if required\\n ctx = self.context\\n lout = ctx.get_log_output()\\n if lout and ctx.solver.trace_cpo:\\n stime = time.time()\\n lout.write(\\\"Model '\\\" + str(self.model.get_name()) + \\\"' in CPO format:\\\\n\\\")\\n lout.write(self.cpostr)\\n lout.write(\\\"\\\\n\\\")\\n self.model.write_information(lout)\\n lout.write(\\\"\\\\n\\\")\\n lout.flush()\\n self.process_infos.incr(CpoProcessInfos.MODEL_DUMP_TIME, time.time() - stime)\\n\\n # Dump in dump directory if required\\n if ctx.model.dump_directory:\\n stime = time.time()\\n make_directories(ctx.model.dump_directory)\\n mname = self.model.get_name()\\n if mname is None:\\n mname = \\\"Anonymous\\\"\\n else:\\n # Remove special characters introduced by Jupyter\\n mname = mname.replace('<', '').replace('>', '')\\n file = ctx.model.dump_directory + \\\"/\\\" + mname + \\\".cpo\\\"\\n with utils.open_utf8(file, 'w') as f:\\n f.write(self.cpostr)\\n self.process_infos.incr(CpoProcessInfos.MODEL_DUMP_TIME, time.time() - stime)\\n\\n # Set published indicator\\n self.model_published = True\",\n \"def print_model(self, model):\\n return \\\"null\\\"\",\n \"def _get_summary_struct(self):\\n model_fields = [\\n ('Number of classes', 'num_classes'),\\n ('Number of feature columns', 'num_features'),\\n ('Input image shape', 'input_image_shape'),\\n ]\\n training_fields = [\\n ('Number of examples', 'num_examples'),\\n (\\\"Training loss\\\", 'training_loss'),\\n (\\\"Training time (sec)\\\", 'training_time'),\\n ]\\n\\n section_titles = ['Schema', 'Training summary']\\n return([model_fields, training_fields], section_titles)\",\n \"def summary_page() :\\r\\n logger.debug(\\\"\\\")\\r\\n model = session_info.get_user_model(session)\\r\\n return render_template( \\\"summary_page.html\\\" , model=model ,\\r\\n stat_types=param_stats.StatTypes )\",\n \"def summary(app):\\n click.echo(get_summary(app))\",\n \"def summary(self):\\n\\n print(\\\"input label:\\\", self.__input_label)\\n print(\\\"target label:\\\", self.__target_label)\\n print(\\\"denoising label:\\\", self.denoising_label)\\n print(\\\"contains a successful DE:\\\", self.is_successful())\",\n \"def create_summary_statistics(forward_accuracy, backward_accuracy, merged_accuracy):\\n summary_statistics = open(f'summary_statistics.txt', 'a')\\n summary_statistics.write(f'The forward model has an accuracy of: {forward_accuracy}\\\\n')\\n summary_statistics.write(f'The backward model has an accuracy of: {backward_accuracy}\\\\n')\\n summary_statistics.write(f'The merged model has an accuracy of: {merged_accuracy}\\\\n')\\n summary_statistics.close()\",\n \"def printModel(self):\\n print(self.model)\",\n \"def summary(self):\\r\\n self.base.summary()\\r\\n self.extra_layers.summary()\\r\\n self.detector.summary()\",\n \"def save_graph_summary(self):\\n writer = tf.summary.FileWriter(LOG_PATH)\\n writer.add_graph(self.graph)\",\n \"def summary(self, summary: str):\\n return self.swag({\\n 'summary': summary\\n })\",\n \"def show_performance(model):\\n val_image_ids_ = [i for i in val_image_ids]\\n np.random.shuffle(val_image_ids_)\\n\\n df_val = area_filter(val_image_ids_, val_coco)\\n image_id = df_val['image_id'].iloc[0]\\n annotation_ids = df_val[df_val['image_id'] == image_id]['annotation_id'].tolist()\\n\\n image_json = val_coco.loadImgs([image_id])[0]\\n raw_image = cv2.imread(os.path.join(\\\"{}/{}/{}\\\".format(data_dir, val_type, image_json['file_name'])))\\n height, width, _ = raw_image.shape\\n\\n # decode the mask, using annotation id created at the group by above\\n binary_mask = process_mask(val_coco, annotation_ids, width, height)\\n\\n # preprocess input and mask (resize to 128, scale to [0, 1))\\n input_image, input_mask = preprocess(raw_image, binary_mask)\\n\\n input_mask = np.expand_dims(input_mask, axis=-1)\\n predicted_mask = model.predict(np.array([input_image]))[0]\\n\\n plt.figure(figsize=(20, 20))\\n\\n title = ['Input Image', 'True Mask', 'Predicted Mask']\\n display_list = [input_image[:, :, ::-1], input_mask, predicted_mask]\\n for i in range(len(display_list)):\\n plt.subplot(1, len(display_list), i+1)\\n plt.title(title[i])\\n plt.imshow(array_to_img(display_list[i]))\\n plt.axis('off')\\n plt.show()\",\n \"def save_model(model, loss, inner_val_loss, mean_outer_val_loss, mean_test_loss, fpath):\\n\\n\\t# Dump data\\n\\twith open(fpath + '.json', 'w') as structure_fpath:\\n\\t\\tjson.dump(model.to_json(), structure_fpath)\\n\\tlogging.info('...saved structural information')\\n\\n\\t# Dump weights\\n\\tmodel.save_weights(fpath + '.h5', overwrite = True)\\n\\tlogging.info('...saved weights')\\n\\n\\t# Dump image\\n\\ttry:\\n\\t\\tplot(model, to_file = fpath + '.png')\\n\\t\\tlogging.info('...saved image')\\n\\texcept:\\n\\t\\tpass\\n\\n\\t# Dump history\\n\\tsave_model_history_manual(loss, inner_val_loss, fpath + '.hist')\\n\\n\\tmean_loss = loss[-1]\\n\\tmean_inner_val_loss = inner_val_loss[-1]\\n\\twrite_loss_report(mean_loss, mean_inner_val_loss, mean_outer_val_loss, mean_test_loss, fpath + '_loss_report.txt')\\n\\tlogging.info ('...saved history')\\n\\n\\tlogging.info('...saved model to {}.[json, h5, png]'.format(fpath))\",\n \"def ribovision_model_info(filename, output):\\n r2dt.write_ribovision(filename, output)\",\n \"def dump(self, model_name: str) -> None:\\n # Dump each preprocessor\\n for index, preprocessor in enumerate(self._preprocessors):\\n model_filename = Files.MODEL_PREPROCESSOR_MODEL_FMT.format(\\n model_name, index)\\n joblib.dump(preprocessor, model_filename)\\n\\n # Dump the scalar\\n filename = Files.MODEL_PREPROCESSOR_MODEL_FMT.format(\\n model_name, Packages.Models.Training.SCALAR_MODEL_NAME)\\n joblib.dump(self._last_scalar_model, filename)\\n\\n # Dump the dimensionality reduction model\\n reduction_model_path = Files.MODEL_REDUCTION_MODEL_FMT.format(\\n model_name)\\n joblib.dump(self._reduction_model, reduction_model_path)\",\n \"def summary(self):\\n for i,layer in enumerate(self.chain):\\n x = Input([2])\\n y = layer.forward(x)\\n Model(x,y,name=f'layer_{i}_summary').summary()\",\n \"def load_model(self):\\n self.loaded_model = keras.models.load_model(self.path)\\n return self.loaded_model.summary()\",\n \"def write(self, model):\\n\\n # Initialize json_dump\\n json_dump = {\\\"model\\\": [], \\\"metadata\\\": {}}\\n\\n # Set timestamp in metadata\\n json_dump[\\\"metadata\\\"][\\\"time\\\"] = str(datetime.now())\\n\\n # Set the size of the model in metadata\\n json_dump[\\\"metadata\\\"][\\\"model_size\\\"] = len(model.models)\\n\\n for obj in model.models:\\n _class = type(obj).__name__\\n if _class in [\\n Winding,\\n PhaseWinding,\\n Wire,\\n PhaseCapacitor,\\n Position,\\n PhaseLoad,\\n ]:\\n continue\\n json_dump[\\\"model\\\"].append({})\\n json_dump[\\\"model\\\"][-1][\\\"class\\\"] = _class\\n\\n try:\\n json_dump[\\\"model\\\"][-1][\\\"name\\\"] = {\\\"class\\\": \\\"str\\\", \\\"value\\\": obj.name}\\n except:\\n json_dump[\\\"model\\\"][-1][\\\"name\\\"] = {\\\"class\\\": \\\"str\\\", \\\"value\\\": None}\\n pass\\n\\n for key, value in obj._trait_values.items():\\n if key in [\\\"capacitance_matrix\\\", \\\"impedance_matrix\\\", \\\"reactances\\\"]:\\n json_dump[\\\"model\\\"][-1][key] = {\\\"class\\\": \\\"list\\\", \\\"value\\\": []}\\n for v in value:\\n if isinstance(v, complex):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"complex\\\", \\\"value\\\": [v.real, v.imag]}\\n )\\n elif isinstance(v, list):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"list\\\", \\\"value\\\": []}\\n )\\n for vv in v:\\n if isinstance(vv, complex):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"value\\\"\\n ].append(\\n {\\n \\\"class\\\": \\\"complex\\\",\\n \\\"value\\\": [vv.real, vv.imag],\\n }\\n )\\n else:\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"value\\\"\\n ].append(\\n {\\n \\\"class\\\": str(type(vv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vv,\\n }\\n )\\n else:\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": str(type(v)).split(\\\"'\\\")[1], \\\"value\\\": v}\\n )\\n continue\\n if isinstance(value, list):\\n json_dump[\\\"model\\\"][-1][key] = {\\\"class\\\": \\\"list\\\", \\\"value\\\": []}\\n for v in value:\\n\\n if isinstance(v, complex):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"complex\\\", \\\"value\\\": [v.real, v.imag]}\\n )\\n\\n elif isinstance(v, Position):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"Position\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n\\n elif isinstance(v, Unicode):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"Unicode\\\", \\\"value\\\": v.default_value}\\n )\\n\\n elif isinstance(v, Wire):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"Wire\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n\\n elif isinstance(v, PhaseCapacitor):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"PhaseCapacitor\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n\\n elif isinstance(v, Winding):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"Winding\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n if kkk != \\\"phase_windings\\\":\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"phase_windings\\\"\\n ] = {\\\"class\\\": \\\"list\\\", \\\"value\\\": []}\\n for phw in v.phase_windings:\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"phase_windings\\\"\\n ][\\\"value\\\"].append({\\\"class\\\": \\\"PhaseWinding\\\"})\\n for kkkk, vvvv in phw._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"phase_windings\\\"\\n ][\\\"value\\\"][-1][kkkk] = {\\n \\\"class\\\": str(type(vvvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvvv,\\n }\\n\\n elif isinstance(v, PhaseLoad):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"PhaseLoad\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n\\n continue\\n\\n if isinstance(value, complex):\\n json_dump[\\\"model\\\"][-1][key] = {\\n \\\"class\\\": \\\"complex\\\",\\n \\\"value\\\": [value.real, value.imag],\\n }\\n continue\\n\\n json_dump[\\\"model\\\"][-1][key] = {\\n \\\"class\\\": str(type(value)).split(\\\"'\\\")[1],\\n \\\"value\\\": value,\\n }\\n\\n with open(os.path.join(self.output_path, self.filename), \\\"w\\\") as f:\\n f.write(\\n json_tricks.dumps(json_dump, allow_nan=True, sort_keys=True, indent=4)\\n )\",\n \"def log_model_info(log_file: str, full_train_state: train_state_lib.TrainState,\\n partitioner: partitioning.BasePartitioner):\\n # Only write logs on host 0.\\n if jax.process_index() != 0:\\n return\\n\\n state_dict = full_train_state.state_dict()\\n param_state_dict = state_dict['target']\\n total_num_params = jax.tree_util.tree_reduce(\\n np.add, jax.tree_map(np.size, param_state_dict))\\n\\n param_logical_axes = partitioner.get_logical_axes(\\n full_train_state).state_dict()['target']\\n\\n param_mesh_axes = jax.tree_map(\\n lambda x: tuple(x) if x is not None else None,\\n partitioner.get_mesh_axes(full_train_state).state_dict()['target'])\\n\\n def _log_info_and_write_to_file(writer, format_str, *args):\\n logging.info(format_str, *args)\\n writer.write(format_str % args + '\\\\n')\\n\\n with gfile.GFile(log_file, 'w') as writer:\\n\\n # Log params\\n def _log_param(name: str, arr: np.ndarray,\\n logical_axes: Optional[partitioning.AxisNames],\\n mesh_axes: Optional[partitioning.PartitionSpec]):\\n if logical_axes is None:\\n shape_str = str(arr.shape)\\n else:\\n assert len(logical_axes) == len(arr.shape)\\n shape_str = '({})'.format(', '.join(\\n f'{name}={dimension}'\\n for name, dimension in zip(logical_axes, arr.shape)))\\n _log_info_and_write_to_file(\\n writer, 'Variable %-80s size %-12s shape %-40s partition spec %s',\\n name, arr.size, shape_str, mesh_axes)\\n\\n jax.tree_map(_log_param, state_utils.get_name_tree(param_state_dict),\\n param_state_dict, param_logical_axes, param_mesh_axes)\\n\\n _log_info_and_write_to_file(writer, 'Total number of parameters: %d',\\n total_num_params)\\n\\n # Add a blank line between params and states.\\n _log_info_and_write_to_file(writer, '')\\n\\n # Log states\\n def _log_state(name, arr):\\n if arr is None:\\n _log_info_and_write_to_file(writer, 'State %-80s None', name)\\n else:\\n _log_info_and_write_to_file(writer,\\n 'State %-80s size %-12s shape %s', name,\\n arr.size, arr.shape)\\n\\n jax.tree_map(_log_state, state_utils.get_name_tree(state_dict['state']),\\n state_dict['state'])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73806274","0.7147296","0.6999165","0.6930897","0.68741435","0.6732777","0.67200786","0.6702313","0.6616318","0.65155643","0.6488972","0.6480176","0.6442557","0.64185977","0.6416413","0.6397906","0.6342395","0.63167113","0.63136315","0.6211133","0.620451","0.6184558","0.6125917","0.60407835","0.5997129","0.5974154","0.5956726","0.59416246","0.589099","0.5879752","0.5798037","0.5798037","0.5794074","0.57489026","0.57281375","0.57113147","0.57001674","0.56893533","0.56807566","0.5659331","0.563871","0.562797","0.5621189","0.5601882","0.559807","0.5591748","0.55900306","0.5583122","0.55820835","0.5579821","0.55592394","0.55551916","0.5550325","0.5550103","0.5540493","0.5533982","0.55329436","0.5531642","0.5518223","0.5497497","0.5494639","0.5488766","0.5483717","0.5459991","0.54580307","0.54381514","0.5437414","0.54294264","0.5418519","0.54120076","0.54089314","0.53980154","0.539377","0.5379878","0.53785247","0.5341001","0.53300434","0.5324339","0.529196","0.52747303","0.5268623","0.52684486","0.5266647","0.5265179","0.5254992","0.52530396","0.5250056","0.52459973","0.5244041","0.5242759","0.5230229","0.52239066","0.5212089","0.5192411","0.5191591","0.5188423","0.5185094","0.5183167","0.51803166","0.51711833"],"string":"[\n \"0.73806274\",\n \"0.7147296\",\n \"0.6999165\",\n \"0.6930897\",\n \"0.68741435\",\n \"0.6732777\",\n \"0.67200786\",\n \"0.6702313\",\n \"0.6616318\",\n \"0.65155643\",\n \"0.6488972\",\n \"0.6480176\",\n \"0.6442557\",\n \"0.64185977\",\n \"0.6416413\",\n \"0.6397906\",\n \"0.6342395\",\n \"0.63167113\",\n \"0.63136315\",\n \"0.6211133\",\n \"0.620451\",\n \"0.6184558\",\n \"0.6125917\",\n \"0.60407835\",\n \"0.5997129\",\n \"0.5974154\",\n \"0.5956726\",\n \"0.59416246\",\n \"0.589099\",\n \"0.5879752\",\n \"0.5798037\",\n \"0.5798037\",\n \"0.5794074\",\n \"0.57489026\",\n \"0.57281375\",\n \"0.57113147\",\n \"0.57001674\",\n \"0.56893533\",\n \"0.56807566\",\n \"0.5659331\",\n \"0.563871\",\n \"0.562797\",\n \"0.5621189\",\n \"0.5601882\",\n \"0.559807\",\n \"0.5591748\",\n \"0.55900306\",\n \"0.5583122\",\n \"0.55820835\",\n \"0.5579821\",\n \"0.55592394\",\n \"0.55551916\",\n \"0.5550325\",\n \"0.5550103\",\n \"0.5540493\",\n \"0.5533982\",\n \"0.55329436\",\n \"0.5531642\",\n \"0.5518223\",\n \"0.5497497\",\n \"0.5494639\",\n \"0.5488766\",\n \"0.5483717\",\n \"0.5459991\",\n \"0.54580307\",\n \"0.54381514\",\n \"0.5437414\",\n \"0.54294264\",\n \"0.5418519\",\n \"0.54120076\",\n \"0.54089314\",\n \"0.53980154\",\n \"0.539377\",\n \"0.5379878\",\n \"0.53785247\",\n \"0.5341001\",\n \"0.53300434\",\n \"0.5324339\",\n \"0.529196\",\n \"0.52747303\",\n \"0.5268623\",\n \"0.52684486\",\n \"0.5266647\",\n \"0.5265179\",\n \"0.5254992\",\n \"0.52530396\",\n \"0.5250056\",\n \"0.52459973\",\n \"0.5244041\",\n \"0.5242759\",\n \"0.5230229\",\n \"0.52239066\",\n \"0.5212089\",\n \"0.5192411\",\n \"0.5191591\",\n \"0.5188423\",\n \"0.5185094\",\n \"0.5183167\",\n \"0.51803166\",\n \"0.51711833\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7225569"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":4485,"cells":{"query":{"kind":"string","value":"Writes a human readable summary of the present model to logging.info, and logs the number of trainable parameters to AzureML."},"document":{"kind":"string","value":"def generate_and_print_model_summary(config: ModelConfigBase, model: DeviceAwareModule) -> None:\n random_state = RandomStateSnapshot.snapshot_random_state()\n # There appears to be a bug in apex, where previous use (in training for example) causes problems\n # when another model is later built on the CPU (for example, before loading from a checkpoint)\n # https://github.com/NVIDIA/apex/issues/694\n # Hence, move the model to the GPU before doing model summary.\n if config.use_gpu:\n model = model.cuda()\n if isinstance(config, ScalarModelBase):\n # To generate the model summary, read the first item of the dataset. Then use the model's own\n # get_model_input function to convert the dataset item to input tensors, and feed them through the model.\n train_dataset = config.get_torch_dataset_for_inference(ModelExecutionMode.TRAIN)\n train_item_0 = next(iter(train_dataset.as_data_loader(shuffle=False, batch_size=1, num_dataload_workers=0)))\n model_inputs = get_scalar_model_inputs_and_labels(config, model, train_item_0).model_inputs\n # The model inputs may already be converted to float16, assuming that we would do mixed precision.\n # However, the model is not yet converted to float16 when this function is called, hence convert back to float32\n summary = ModelSummary(model)\n summary.generate_summary(input_tensors=model_inputs, log_summaries_to_files=config.log_summaries_to_files)\n elif config.is_segmentation_model:\n summary_for_segmentation_models(config, model)\n assert model.summarizer\n summary = model.summarizer # type: ignore\n else:\n raise ValueError(\"Don't know how to generate a summary for this type of model?\")\n RUN_CONTEXT.log(LoggingColumns.NumTrainableParameters, summary.n_trainable_params)\n random_state.restore_random_state()"},"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 summary(self):\n\n self.model.summary(print_fn=lambda x: logging.info(x))","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_summary(self):\n self.model.summary()","def log_model_info(log_file: str, full_train_state: train_state_lib.TrainState,\n partitioner: partitioning.BasePartitioner):\n # Only write logs on host 0.\n if jax.process_index() != 0:\n return\n\n state_dict = full_train_state.state_dict()\n param_state_dict = state_dict['target']\n total_num_params = jax.tree_util.tree_reduce(\n np.add, jax.tree_map(np.size, param_state_dict))\n\n param_logical_axes = partitioner.get_logical_axes(\n full_train_state).state_dict()['target']\n\n param_mesh_axes = jax.tree_map(\n lambda x: tuple(x) if x is not None else None,\n partitioner.get_mesh_axes(full_train_state).state_dict()['target'])\n\n def _log_info_and_write_to_file(writer, format_str, *args):\n logging.info(format_str, *args)\n writer.write(format_str % args + '\\n')\n\n with gfile.GFile(log_file, 'w') as writer:\n\n # Log params\n def _log_param(name: str, arr: np.ndarray,\n logical_axes: Optional[partitioning.AxisNames],\n mesh_axes: Optional[partitioning.PartitionSpec]):\n if logical_axes is None:\n shape_str = str(arr.shape)\n else:\n assert len(logical_axes) == len(arr.shape)\n shape_str = '({})'.format(', '.join(\n f'{name}={dimension}'\n for name, dimension in zip(logical_axes, arr.shape)))\n _log_info_and_write_to_file(\n writer, 'Variable %-80s size %-12s shape %-40s partition spec %s',\n name, arr.size, shape_str, mesh_axes)\n\n jax.tree_map(_log_param, state_utils.get_name_tree(param_state_dict),\n param_state_dict, param_logical_axes, param_mesh_axes)\n\n _log_info_and_write_to_file(writer, 'Total number of parameters: %d',\n total_num_params)\n\n # Add a blank line between params and states.\n _log_info_and_write_to_file(writer, '')\n\n # Log states\n def _log_state(name, arr):\n if arr is None:\n _log_info_and_write_to_file(writer, 'State %-80s None', name)\n else:\n _log_info_and_write_to_file(writer,\n 'State %-80s size %-12s shape %s', name,\n arr.size, arr.shape)\n\n jax.tree_map(_log_state, state_utils.get_name_tree(state_dict['state']),\n state_dict['state'])","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 summary(self) -> None:\n print(\"Model manager summary:\")\n print(\"Preprocessor:\")\n print(self.preprocessor)\n print(\"Model summary:\")\n self.model.summary()\n print(\"Postprocessor:\")\n print(self.postprocessor)","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_summary(self):\n print(\"Word Level\")\n self.model_word.summary()\n \n print(\"Sent Level\")\n self.model_sent.summary()\n\n print(\"Doc Level\")\n self.model.summary()","def summary(self):\r\n print(self.model.summary())","def summary(self):\n print(self.model.summary())","def logging_init(model, graph):\n # Add ops to record summaries for loss and accuracy...\n train_loss = tf.summary.scalar(\"train_loss\", model.loss)\n train_accuracy = tf.summary.scalar(\"train_accuracy\", model.accuracy)\n # ...then merge these ops into one single op so that they easily be run\n # together\n train_summary_ops = tf.summary.merge([train_loss, train_accuracy])\n # Same ops, but with different names, so that train/test results show up\n # separately in TensorBoard\n test_loss = tf.summary.scalar(\"test_loss\", model.loss)\n test_accuracy = tf.summary.scalar(\"test_accuracy\", model.accuracy)\n test_summary_ops = tf.summary.merge([test_loss, test_accuracy])\n\n timestamp = int(time.time())\n run_log_dir = os.path.join(LOGS_DIR, str(timestamp))\n os.makedirs(run_log_dir)\n # (this step also writes the graph to the events file so that\n # it shows up in TensorBoard)\n summary_writer = tf.summary.FileWriter(run_log_dir, graph)\n\n return train_summary_ops, test_summary_ops, summary_writer","def create_log(self):\n self.model.graph.get_stats()\n out = self.model.graph.summary\n out[\"training_error\"] = zip(self.train_it, self.train_err)\n out[\"validation_error\"] = zip(self.validation_it, self.validation_err)\n with open(self.log, \"w\") as f:\n f.write(json.dumps(out, default=defaultencode))","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 summary(self):\n self.model.summary()","def model_stats(opt, epoch, model):\n log = rlog.getLogger(opt.experiment + \".model\")\n if hasattr(opt, \"log\") and opt.log.detailed:\n # log histogram also\n assert isinstance(\n model, SVIModel\n ), \"This stat only makes sense for SVI models.\"\n for mu, std in zip(model.mu(), model.std()):\n log.put(mu=mu, std=std)\n log.trace(step=epoch, **model.summarize())\n log.reset()","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_info(self):\r\n self.system.print_to_log(\r\n f\"{self.__class__.__name__} model: Infection probability: {self.p}, Infectious period: {self.i}, Recovery period: {self.r}.\")","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 show_model_summary(self):\n\t\treturn self.model.summary()","def log_best_performer(self) -> None:\n best = self.get_highest_accuracy()\n self.logger.info(f\"\\n\\nThe model with the highest accuracy {best[0]} has the following characteristics: \\n\")\n for k, v in best[1].items():\n if k != 'best_performer':\n self.logger.info(f\"{k} : {v}\")\n else:\n self.logger.info(f\"Best Accuracy: {v['Accuracy']}\")\n self.logger.info(\"Features used: \")\n for f in v['Labels']:\n self.logger.info(f)\n for nw, w in v['Vars'].items():\n self.logger.info(f\"{nw}: {w}\")","def logging(self, function):\n avg_nms_time_per_step = sum(self.nms_times)/len(self.nms_times)\n avg_total_time_per_step = sum(self.total_times)/len(self.total_times)\n\n avg_min_latency = [x[0] for x in self.inference_times]\n avg_max_latency = [x[1] for x in self.inference_times]\n avg_latency = [x[2] for x in self.inference_times]\n\n function(\"Inference stats: image size {}x{}, batches per step {}, batch size {}, {} steps\".format(\n self.cfg.model.image_size, self.cfg.model.image_size, self.cfg.ipuopts.batches_per_step, self.cfg.model.micro_batch_size, len(self.total_times)\n ))\n function(\"--------------------------------------------------\")\n function(\"Inference\")\n function(\"Average Min Latency per Batch: {:.3f} ms\".format(1000 * sum(avg_min_latency)/len(self.inference_times)))\n function(\"Average Max Latency per Batch: {:.3f} ms\".format(1000 * sum(avg_max_latency)/len(self.inference_times)))\n function(\"Average Latency per Batch: {:.3f} ms\".format(1000 * sum(avg_latency)/len(self.inference_times)))\n function(\"Average Inference Throughput: {:.3f} img/s\".format(sum(self.inference_throughputs)/len(self.inference_throughputs)))\n function(\"--------------------------------------------------\")\n # TODO remove the NMS and end-to-end time report once NMS is on device\n function(\"End-to-end\")\n function(\"Average NMS Latency per Batch: {:.3f} ms\".format(1000 * avg_nms_time_per_step/self.cfg.ipuopts.batches_per_step))\n function(\"Average End-to-end Latency per Batch: {:.3f} ms\".format(1000 * avg_total_time_per_step/self.cfg.ipuopts.batches_per_step))\n function(\"End-to-end Throughput: {:.3f} img/s\".format(sum(self.total_throughputs)/len(self.total_throughputs)))\n function(\"==================================================\")\n\n if self.cfg.eval.metrics:\n self.compute_and_print_eval_metrics()","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 on_train_begin(self, logs=None):\n f = open(self.log_file_path, \"a\")\n f.write(f\"{'=' * 5}{self.model_name}({self.hp_log_title}){'=' * 5}\\n\")\n f.close()","def save_summary(model, model_name, stage_no):\n stringlist = []\n model.summary(print_fn=lambda x: stringlist.append(x))\n short_model_summary = \"\\n\".join(stringlist)\n \n with open(eval_path+\"{}_model_summary_stage_{}.txt\".format(model_name, stage_no), \"w\") as text_file:\n print(short_model_summary, file=text_file)","def initialize_summary(self):\n if self.need_logs:\n self.summary_writer = tf.summary.create_file_writer(self.log_dir)\n if self.verbose > 0:\n full_log_path = os.path.abspath(self.log_dir)\n print('Initialize logs, use: \\ntensorboard --logdir={}'.format(full_log_path))","def output_summary(self, v, vhat, sk, logged_matrics, train_dataset_label, val_dataset_label, summary_folder_path):\n\n mse = np.sum((v-vhat)**2)/len(v)\n train_loss = logged_matrics[\"train_loss\"]\n\n k = np.sum(p.numel() for p in self.parameters())\n\n numOfSamples = len(sk)\n aic = 2*k + numOfSamples*np.log(mse) + numOfSamples*(1+np.log(2*np.pi))\n\n summary_file = os.path.join(summary_folder_path, \"model_summary.txt\")\n if not os.path.isfile(summary_file):\n print(\"Created file \"+summary_file)\n with open(summary_file, \"w\") as output:\n output.write(\n \"Model Train_dataset_label Val_dataset_label Train_loss Test_loss AIC\\n\")\n else:\n print(summary_file +\n \" exists, model summary will be attached to the end of this file.\")\n\n with open(summary_file, \"a\") as output:\n model_name = self.version\n output.write(model_name + \" \" + train_dataset_label + \" \" +\n val_dataset_label + \" %f %f %f\\n\" % (train_loss, mse, aic))\n\n\n plt.scatter(sk, v, c=\"blue\", s=2, label=\"true\")\n plt.scatter(sk, vhat, c=\"red\", s=2, label=\"predict\")\n plt.legend()\n plt.xlabel(\"sk\")\n plt.ylabel(\"v\")\n\n plt.savefig(os.path.join(summary_folder_path, \"plots\", model_name+\".png\"))\n plt.show()\n\n np.savetxt(os.path.join(summary_folder_path, \"model_prediction\", model_name+\"_prediction.txt\"), np.column_stack((sk, v, vhat)), header=\"sk v vhat\", fmt='%.8f')\n\n\n print(\"Plot saved as\", os.path.join(summary_folder_path, \"plots\", model_name+\".png\"))\n print(\"Model prediction saved as\", os.path.join(summary_folder_path, \"model_prediction\", model_name+\"_prediction.txt\"))","def summary_info(self):\n return [('model_architecture', self.model_architecture),\n ('input_size', self.input_size),\n ('output_size', self.output_size),\n ('hidden_layers', self.hidden_layers),\n ('learn_rate', self.learn_rate),\n ('drop_p', self.drop_p),\n ('current_epoch', self.model.current_epoch)]","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 test_summaries(self):\n try:\n ans = str(self.model)\n except:\n assert False, \"Model __repr__ failed.\"\n\n try:\n print(self.model)\n except:\n assert False, \"Model print failed.\"\n\n try:\n self.model.summary()\n except:\n assert False, \"Model summary failed.\"","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 execute_summary(self, step):\n with self.summary_writer.as_default():\n tf.summary.scalar('bias', self.core.fmlayer.b, step=step)\n tf.summary.scalar('regularization_penalty', self.regularization, step=step)\n tf.summary.scalar('loss', self.reduced_loss, step=step)\n tf.summary.scalar('target', self.target, step=step)","def log_trainable_variables(self):\n var_names = list(self.trainable_variables.keys())\n self.logger.log_trainable_variables(var_names)","def on_train_begin(self, logs):\n self.train_start = timeit.default_timer()\n self.metrics_names = self.model.metrics_names\n print('Training for {} steps ...'.format(self.params['nb_steps']))","def get_model_info(y_test, model_name, model_parameters, model_preprocessing, sequence_origin, primers_origin,\n taxonomy_level, selected_primer, test_size, logger) -> int:\n\n # Global information on the model\n logger.log(title='Parameter information for {}'.format(model_name))\n # Data Origins\n logger.log(subtitle='Data Origins')\n logger.log(text='Sequence origin: {}'.format(sequence_origin))\n logger.log(text='Primers origin: {}'.format(primers_origin))\n # Chosen levels for classification\n logger.log(subtitle='Chosen HyperVariable Region and Taxonomy Rank')\n logger.log(text='HyperVariable Region: {}'.format(str(selected_primer)))\n logger.log(text='Taxonomy Rank: {}'.format(str(taxonomy_level)))\n # Applied Preprocessing\n logger.log(subtitle='Preprocessing')\n logger.log(text='Preprocessing description: ' + model_preprocessing)\n # Model parameters\n logger.log(subtitle='Model parameters')\n logger.log(text='Parameter dict: {}'.format(str(model_parameters)))\n logger.log(text='Size of test set: {}'.format(len(y_test)))\n logger.log(text='Part of test size compared to total: {}'.format(test_size))\n\n return len(y_test)","def log_training_results(engine: Engine):\n train_evaluator.run(self.train_dl)\n metrics: Dict[str, float] = train_evaluator.state.metrics\n avg_accuracy: float = metrics['accuracy']\n avg_bce: float = metrics['bce']\n pbar.log_message(\n f'Training Results - Epoch: {engine.state.epoch} Avg accuracy: {avg_accuracy:.4f} Avg loss: {avg_bce:.4f}')","def _setup_summaries(self, sess):\n # Output directory for models and summaries\n\n\n print(\"Writing to {}\\n\".format(os.path.abspath(self._log_dir)))\n\n train_summary_dir = os.path.join(self._log_dir, \"summaries\", \"train\")\n self._train_summary_writer = tf.summary.FileWriter(train_summary_dir, sess.graph)\n\n val_summary_dir = os.path.join(self._log_dir, \"summaries\", \"validation\")\n self._val_summary_writer = tf.summary.FileWriter(val_summary_dir, sess.graph)\n\n # Model checkpoints\n # Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it\n self.checkpoint_dir = os.path.abspath(os.path.join(self._save_dir, \"checkpoints/\"))\n\n if not os.path.exists(self.checkpoint_dir):\n os.makedirs(self.checkpoint_dir)\n\n self._saver = tf.train.Saver(max_to_keep=10) # Save model after each epoch\n\n self.train_summary_op = tf.summary.merge(self._train_summaries)\n self.val_summary_op = tf.summary.merge(self._val_summaries)\n\n print(\"--------------------------------------------------\")\n print(\"\\ntensorboard --logdir {}\".format(os.path.abspath(self._log_dir)))\n print(\"\\ntensorboard --logdir {} --port 6007\".format(os.path.abspath(self.checkpoint_dir)))\n print(\"--------------------------------------------------\")","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 _summary(self):\n trainable_variable = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n for var in trainable_variable:\n tf.summary.histogram(var.op.name, var)\n\n self.merged_summary_op = tf.summary.merge_all()","def log_output_data(self):\r\n with tf.name_scope('model_output'):\r\n for i in range(self.action_handler.get_number_actions()):\r\n variable_name = str(self.action_handler.action_list_names[i])\r\n tf.summary.histogram(variable_name + '_output', self.actor_last_row_layer[i])","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 summary(self):\n\n print(\"input label:\", self.__input_label)\n print(\"target label:\", self.__target_label)\n print(\"denoising label:\", self.denoising_label)\n print(\"contains a successful DE:\", self.is_successful())","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_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 print_summary(self):\n self.network.print_summary()","def training_info(self):\n pass","def on_train_begin(self, logs):\n print(f\"Testing for {self.params['nb_episodes']} episodes ...\")","def _log_weights(self, epoch):\r\n writer = self._get_writer(self._train_run_name)\r\n with context.eager_mode(), \\\r\n writer.as_default(), \\\r\n summary_ops_v2.always_record_summaries():\r\n for layer in self.model.layers:\r\n for weight in layer.weights:\r\n weight_name = weight.name.replace(':', '_')\r\n with ops.init_scope():\r\n weight = K.get_value(weight)\r\n summary_ops_v2.histogram(weight_name, weight, step=epoch)\r\n if self.write_images:\r\n self._log_weight_as_image(weight, weight_name, epoch)\r\n writer.flush()","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 write_training_summaries(self):\n for metric, epochs in self._training_summaries.items():\n self._write_scalar_to_tensorboard(\n name=f\"{self._Sections.SUMMARY}/training_{metric}\",\n value=epochs[-1],\n step=self._epochs,\n )","def summary(self):\n return self.model.summary()","def print_summary(self, print_level = 0):\n\n print(\"==========================\")\n print(\"= FUNtoFEM model summary =\")\n print(\"==========================\")\n print(\"Model name:\", self.name)\n print(\"Number of bodies:\", len(self.bodies))\n print(\"Number of scenarios:\", len(self.scenarios))\n print(\" \")\n print(\"------------------\")\n print(\"| Bodies summary |\")\n print(\"------------------\")\n for body in self.bodies:\n print(\"Body:\", body.id, body.name)\n print(\" coupling group:\", body.group)\n print(\" transfer scheme:\", type(body.transfer))\n print(\" shape parameteration:\", type(body.shape))\n for vartype in body.variables:\n print(' variable type:', vartype)\n print(' number of ', vartype, ' variables:', len(body.variables[vartype]))\n if print_level >= 0:\n for var in body.variables[vartype]:\n print(' variable:', var.name, ', active?', var.active,', coupled?', var.coupled)\n print(' value and bounds:', var.value, var.lower, var.upper)\n\n print(\" \")\n print(\"--------------------\")\n print(\"| Scenario summary |\")\n print(\"--------------------\")\n for scenario in self.scenarios:\n print(\"scenario:\", scenario.id, scenario.name)\n print(\" coupling group:\", scenario.group)\n print(\" steps:\", scenario.steps)\n print(\" steady?:\", scenario.steady)\n for func in scenario.functions:\n print(' function:', func.name, ', analysis_type:', func.analysis_type)\n print(' adjoint?', func.adjoint)\n if not scenario.steady:\n print(' time range', func.start, ',', func.stop)\n print(' averaging', func.averaging)\n\n\n for vartype in scenario.variables:\n print(' variable type:', vartype)\n print(' number of ', vartype, ' variables:', len(scenario.variables[vartype]))\n if print_level >= 0:\n for var in scenario.variables[vartype]:\n print(' variable:', var.id, var.name, ', active?', var.active,', coupled?', var.coupled)\n print(' value and bounds:', var.value, var.lower, var.upper)","def test_get_summary_with_model(self):\n\t\t\n\t\tdescription = self.watcher.describe(model=self.model)\n\t\tself.assertEqual(11, len(description))\n\t\t\n\t\t\n\t\tdetails = self.watcher.analyze(model=self.model, layers=[self.second_layer])\n\t\treturned_summary = self.watcher.get_summary(details)\n\t\t\n\t\tprint(returned_summary)\n\t\t\n\t\tsaved_summary = self.watcher.get_summary()\n\t\tself.assertEqual(returned_summary, saved_summary)","def log_info(self, logger, opt_loc=''):\n if len(np.unique(self._lr)) == 1:\n logger.info('Using %s %s optimizer with lr = %.5f.' % \\\n (self.name, opt_loc, self._lr[0]))\n else:\n logger.info('Using %s %s optimizer with:' % (self.name, opt_loc))\n for forward_opt in self._optimizer_list:\n assert len(forward_opt.param_groups) == 1\n lr = forward_opt.param_groups[0]['lr']\n shapes = str([list(pm.shape) for pm in \\\n forward_opt.param_groups[0]['params']])\n logger.info(' lr = %.3f for params with shape %s.' % \\\n (lr, shapes[1:-1]))","def _compute_statistics(self):\n # log to file\n output_dir = self.params['output_dir']\n if not os.path.exists(output_dir):\n os.mkdir(output_dir)\n output_dir = os.path.join(output_dir, 'statistics.log')\n log = logging.getLogger('tensorflow')\n handle = logging.FileHandler(output_dir)\n log.addHandler(handle)\n\n # FLOPS\n encoder_flops, decoder_flops = 0, 0\n encoder_count, decoder_count = 0, 0\n graph = tf.get_default_graph()\n for operation in graph.get_operations():\n flops = ops.get_stats_for_node_def(graph, operation.node_def,\n 'flops').value\n if flops is None:\n continue\n if operation.name.startswith('model/encoder'):\n # encoder\n encoder_flops += flops\n encoder_count += 1\n tf.logging.info('encoder operation %s : %d', operation.name, flops)\n elif operation.name.startswith('model/decoder'):\n # decoder\n decoder_flops += flops\n decoder_count += 1\n tf.logging.info('decoder operation %s : %d', operation.name, flops)\n else:\n # gradient\n pass\n tf.logging.info('flops of %d encoder tensor: %d',\n encoder_count, encoder_flops)\n tf.logging.info('flops of %d decoder tensor: %d',\n decoder_count, decoder_flops)\n tf.logging.info('flops of total %d tensor: %d',\n encoder_count + decoder_count,\n encoder_flops + decoder_flops)\n # parameters\n encoder_parameters, decoder_parameters = 0, 0\n encoder_count, decoder_count = 0, 0\n for var in tf.trainable_variables():\n parameters = np.prod(var.get_shape().as_list())\n if var.name.startswith('model/encoder'):\n # encoder\n encoder_parameters += parameters\n encoder_count += 1\n tf.logging.info('encoder variable %s : %d', var.name, parameters)\n elif var.name.startswith('model/decoder'):\n # decoder\n decoder_parameters += parameters\n decoder_count += 1\n tf.logging.info('decoder variable %s : %d', var.name, parameters)\n\n tf.logging.info('parameters of %d encoder tensor: %d',\n encoder_count, encoder_parameters)\n tf.logging.info('parameters of %d decoder tensor: %d',\n decoder_count, decoder_parameters)\n tf.logging.info('parameters of total %d tensor: %d',\n encoder_count + decoder_count,\n encoder_parameters + decoder_parameters)\n # disable log to file\n log.removeHandler(handle)","def log_hyperparameters(\n cfg: DictConfig,\n model: pl.LightningModule,\n trainer: pl.Trainer,\n) -> None:\n hparams = OmegaConf.to_container(cfg, resolve=True)\n\n # save number of model parameters\n hparams[f\"{STATS_KEY}/params_total\"] = sum(p.numel() for p in model.parameters())\n hparams[f\"{STATS_KEY}/params_trainable\"] = sum(\n p.numel() for p in model.parameters() if p.requires_grad\n )\n hparams[f\"{STATS_KEY}/params_not_trainable\"] = sum(\n p.numel() for p in model.parameters() if not p.requires_grad\n )\n\n # send hparams to all loggers\n trainer.logger.log_hyperparams(hparams)\n\n # disable logging any more hyperparameters for all loggers\n # (this is just a trick to prevent trainer from logging hparams of model, since we already did that above)\n trainer.logger.log_hyperparams = lambda params: None","def summary(self):\r\n self.base.summary()\r\n self.extra_layers.summary()\r\n self.detector.summary()","def summary(self):\n for i,layer in enumerate(self.chain):\n x = Input([2])\n y = layer.forward(x)\n Model(x,y,name=f'layer_{i}_summary').summary()","def _log_metrics(\n self,\n train_writer: SummaryWriter,\n val_writer: SummaryWriter,\n timestamped_save_dir: Path,\n train_metrics: _Metrics,\n step: int,\n ) -> None:\n if len(self.val_loader) > 0:\n val_metrics, val_img, val_gt, val_pred = self._get_val_metrics()\n if val_metrics.accuracy > self.best_acc:\n self.best_acc = val_metrics.accuracy\n self.save_weights(timestamped_save_dir, True)\n\n for key in vars(train_metrics):\n if key == \"class_loss\":\n tag = \"losses/classification\"\n elif key in {\"shape_loss\", \"total_loss\"}:\n continue\n else:\n tag = f\"metrics/{key}\"\n\n train_writer.add_scalar(tag, getattr(train_metrics, key), step)\n if len(self.val_loader) > 0:\n val_writer.add_scalar(tag, getattr(val_metrics, key), step)\n\n reg_loss = self._get_l2_reg()\n train_writer.add_scalar(\"losses/regularization\", reg_loss, step)\n train_writer.add_scalar(\"losses/shape\", train_metrics.shape_loss, step)\n train_writer.add_scalar(\n \"losses/total\",\n train_metrics.total_loss + self.config.weight_decay * reg_loss,\n step,\n )\n\n # Log a histogram for each tensor parameter in the model, to\n # see if a parameter is training stably or not\n for name, value in self.model.state_dict().items():\n train_writer.add_histogram(name, value, step)\n\n # Log the validation images for easy visualization\n if len(self.val_loader) > 0:\n val_writer.add_images(\"input\", val_img, step)\n val_writer.add_images(\"ground_truth\", val_gt, step)\n val_writer.add_images(\"prediction\", val_pred, step)","def _logging(self):\n msgs = []\n # patch to log stdout spawned processes of dataloader\n logger = init_logger()\n for ds_name, ds_count in self._counts.items():\n msgs.append(f\"\\t\\t\\t* {ds_name}: {ds_count}\")\n logger.info(\"Weighted corpora loaded so far:\\n\" + \"\\n\".join(msgs))","def build_summary(self):\n assert self.mode==\"train\"\n\n for var in tf.trainable_variables():\n with tf.name_scope(var.name[:var.name.find(\":\")]):\n with tf.name_scope(\"values\"):\n self.variable_summary(var)\n\n for g, var in zip(self.gs, self.g_vars):\n with tf.name_scope(var.name[:var.name.find(\":\")]):\n with tf.name_scope(\"gradients\"):\n self.variable_summary(g)\n\n with tf.name_scope(\"cross_entropies\"):\n self.variable_summary(self.cross_entropies)\n\n with tf.name_scope(\"attention\"):\n self.variable_summary(self.sum_alpha) \n\n with tf.name_scope(\"scores\"):\n self.variable_summary(self.scores) \n\n tf.summary.scalar(\"num_correct_words\", self.num_correct_words)\n\n tf.summary.scalar(\"cross_entropy_loss\", self.cross_entropy_loss)\n tf.summary.scalar(\"attention_loss\", self.attention_loss)\n tf.summary.scalar(\"l2_loss\", self.l2_loss)\n tf.summary.scalar(\"loss\", self.loss)\n \n self.summary = tf.summary.merge_all()","def on_train_begin(self, logs=None):","def on_train_begin(self, logs=None):","def print_network(self):\n #plot_model(self.model, to_file='model.png', show_shapes=True)\n logging.info(\"\")\n logging.info(self.network)\n logging.info(\"Network accuracy: %.2f%%\" % (self.accuracy * 100))\n logging.info(\"Network loss: %.2f%%\" % (self.loss))","def logging_summaries(\n summary_writer: tf.contrib.summary.SummaryWriter, logged: Dict\n) -> None:\n\n with summary_writer.as_default(), tf.contrib.summary.always_record_summaries():\n tf.contrib.summary.image(\"generated\", logged[\"generated_data\"])\n tf.contrib.summary.image(\"real\", logged[\"real_data\"])\n tf.contrib.summary.scalar(\"generator/loss\", logged[\"gen_loss\"])\n tf.contrib.summary.scalar(\"discriminator/loss\", logged[\"disc_loss\"])","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 on_log(self):\n monitors = self.monitors\n if self.monitors is None:\n monitors = self.trainer.metrics.keys()\n\n\n hparams = self.hparams\n if self.hparams is None:\n hparams = self.trainer.hparams.keys()\n\n metrics = {name: format_metric(self.trainer.metrics[name])\n for name in monitors\n if name in self.trainer.metrics}\n hparams = {name: format_metric(self.trainer.hparams[name])\n for name in hparams\n if name in self.trainer.hparams}\n\n\n step_bar = self.step_bars[-1]\n step_bar.set_description(\"Epoch {}\".format(self.trainer.epoch+1))\n step_bar.set_postfix(**metrics, **hparams)\n step_bar.update(self.trainer.steps_trained - self.last_step)\n self.last_step = self.trainer.steps_trained","def _save_model_info(self, model):\r\n with open_(self.output_path / \"model.info\", \"w+\") as f:\r\n f.write(model.info)","def autolog(\n every_n_iter=1,\n log_models=True,\n disable=False,\n exclusive=False,\n disable_for_unsupported_versions=False,\n silent=False,\n): # pylint: disable=unused-argument\n # pylint: disable=E0611\n import tensorflow\n\n global _LOG_EVERY_N_STEPS\n _LOG_EVERY_N_STEPS = every_n_iter\n\n atexit.register(_flush_queue)\n\n if Version(tensorflow.__version__) < Version(\"1.12\"):\n warnings.warn(\"Could not log to MLflow. TensorFlow versions below 1.12 are not supported.\")\n return\n\n try:\n from tensorflow.python.summary.writer.event_file_writer import EventFileWriter\n from tensorflow.python.summary.writer.event_file_writer_v2 import EventFileWriterV2\n from tensorflow.python.saved_model import tag_constants\n from tensorflow.python.summary.writer.writer import FileWriter\n except ImportError:\n warnings.warn(\"Could not log to MLflow. TensorFlow versions below 1.12 are not supported.\")\n return\n\n def train(original, self, *args, **kwargs):\n active_run = mlflow.active_run()\n global _AUTOLOG_RUN_ID\n _AUTOLOG_RUN_ID = active_run.info.run_id\n\n # Checking step and max_step parameters for logging\n if len(args) >= 3:\n mlflow.log_param(\"steps\", args[2])\n if len(args) >= 4:\n mlflow.log_param(\"max_steps\", args[3])\n if \"steps\" in kwargs:\n mlflow.log_param(\"steps\", kwargs[\"steps\"])\n if \"max_steps\" in kwargs:\n mlflow.log_param(\"max_steps\", kwargs[\"max_steps\"])\n\n result = original(self, *args, **kwargs)\n\n # Flush the metrics queue after training completes\n _flush_queue()\n\n # Log Tensorboard event files as artifacts\n if os.path.exists(self.model_dir):\n for file in os.listdir(self.model_dir):\n if \"tfevents\" not in file:\n continue\n mlflow.log_artifact(\n local_path=os.path.join(self.model_dir, file),\n artifact_path=\"tensorboard_logs\",\n )\n return result\n\n def export_saved_model(original, self, *args, **kwargs):\n global _AUTOLOG_RUN_ID\n if _AUTOLOG_RUN_ID:\n _logger.info(\n \"Logging TensorFlow Estimator as MLflow Model to run with ID '%s'\", _AUTOLOG_RUN_ID\n )\n\n serialized = original(self, *args, **kwargs)\n\n def log_model_without_starting_new_run():\n \"\"\"\n Performs the exact same operations as `log_model` without starting a new run\n \"\"\"\n with TempDir() as tmp:\n artifact_path = \"model\"\n local_path = tmp.path(\"model\")\n mlflow_model = Model(artifact_path=artifact_path, run_id=_AUTOLOG_RUN_ID)\n save_model_kwargs = dict(\n tf_saved_model_dir=serialized.decode(\"utf-8\"),\n tf_meta_graph_tags=[tag_constants.SERVING],\n tf_signature_def_key=\"predict\",\n )\n save_model(path=local_path, mlflow_model=mlflow_model, **save_model_kwargs)\n client = MlflowClient()\n client.log_artifacts(_AUTOLOG_RUN_ID, local_path, artifact_path)\n\n try:\n client._record_logged_model(_AUTOLOG_RUN_ID, mlflow_model)\n except MlflowException:\n # We need to swallow all mlflow exceptions to maintain backwards\n # compatibility with older tracking servers. Only print out a warning\n # for now.\n _logger.warning(\n _LOG_MODEL_METADATA_WARNING_TEMPLATE,\n get_artifact_uri(_AUTOLOG_RUN_ID),\n )\n\n log_model_without_starting_new_run()\n\n _AUTOLOG_RUN_ID = None\n\n return serialized\n\n @picklable_exception_safe_function\n def _get_early_stop_callback(callbacks):\n for callback in callbacks:\n if isinstance(callback, tensorflow.keras.callbacks.EarlyStopping):\n return callback\n return None\n\n def _log_early_stop_callback_params(callback):\n if callback:\n try:\n earlystopping_params = {\n \"monitor\": callback.monitor,\n \"min_delta\": callback.min_delta,\n \"patience\": callback.patience,\n \"baseline\": callback.baseline,\n \"restore_best_weights\": callback.restore_best_weights,\n }\n mlflow.log_params(earlystopping_params)\n except Exception: # pylint: disable=W0703\n return\n\n def _get_early_stop_callback_attrs(callback):\n try:\n return callback.stopped_epoch, callback.restore_best_weights, callback.patience\n except Exception: # pylint: disable=W0703\n return None\n\n def _log_early_stop_callback_metrics(callback, history, metrics_logger):\n if callback is None or not callback.model.stop_training:\n return\n\n callback_attrs = _get_early_stop_callback_attrs(callback)\n if callback_attrs is None:\n return\n\n stopped_epoch, restore_best_weights, _ = callback_attrs\n metrics_logger.record_metrics({\"stopped_epoch\": stopped_epoch})\n\n if not restore_best_weights or callback.best_weights is None:\n return\n\n monitored_metric = history.history.get(callback.monitor)\n if not monitored_metric:\n return\n\n initial_epoch = history.epoch[0]\n # If `monitored_metric` contains multiple best values (e.g. [0.1, 0.1, 0.2] where 0.1 is\n # the minimum loss), the epoch corresponding to the first occurrence of the best value is\n # the best epoch. In keras > 2.6.0, the best epoch can be obtained via the `best_epoch`\n # attribute of an `EarlyStopping` instance: https://github.com/keras-team/keras/pull/15197\n restored_epoch = initial_epoch + monitored_metric.index(callback.best)\n metrics_logger.record_metrics({\"restored_epoch\": restored_epoch})\n restored_index = history.epoch.index(restored_epoch)\n restored_metrics = {\n key: metrics[restored_index] for key, metrics in history.history.items()\n }\n # Checking that a metric history exists\n metric_key = next(iter(history.history), None)\n if metric_key is not None:\n metrics_logger.record_metrics(restored_metrics, stopped_epoch + 1)\n\n class FitPatch(PatchFunction):\n def __init__(self):\n self.log_dir = None\n\n def _patch_implementation(\n self, original, inst, *args, **kwargs\n ): # pylint: disable=arguments-differ\n unlogged_params = [\"self\", \"x\", \"y\", \"callbacks\", \"validation_data\", \"verbose\"]\n\n log_fn_args_as_params(original, args, kwargs, unlogged_params)\n early_stop_callback = None\n\n run_id = mlflow.active_run().info.run_id\n with batch_metrics_logger(run_id) as metrics_logger:\n # Check if the 'callback' argument of fit() is set positionally\n if len(args) >= 6:\n # Convert the positional training function arguments to a list in order to\n # mutate the contents\n args = list(args)\n # Make a shallow copy of the preexisting callbacks to avoid permanently\n # modifying their contents for future training invocations. Introduce\n # TensorBoard & tf.keras callbacks if necessary\n callbacks = list(args[5])\n callbacks, self.log_dir = _setup_callbacks(\n callbacks, log_models, metrics_logger\n )\n # Replace the callbacks positional entry in the copied arguments and convert\n # the arguments back to tuple form for usage in the training function\n args[5] = callbacks\n args = tuple(args)\n else:\n # Make a shallow copy of the preexisting callbacks and introduce TensorBoard\n # & tf.keras callbacks if necessary\n callbacks = list(kwargs.get(\"callbacks\") or [])\n kwargs[\"callbacks\"], self.log_dir = _setup_callbacks(\n callbacks, log_models, metrics_logger\n )\n\n early_stop_callback = _get_early_stop_callback(callbacks)\n _log_early_stop_callback_params(early_stop_callback)\n\n history = original(inst, *args, **kwargs)\n\n _log_early_stop_callback_metrics(\n callback=early_stop_callback,\n history=history,\n metrics_logger=metrics_logger,\n )\n\n _flush_queue()\n mlflow.log_artifacts(\n local_dir=self.log_dir.location,\n artifact_path=\"tensorboard_logs\",\n )\n if self.log_dir.is_temp:\n shutil.rmtree(self.log_dir.location)\n\n return history\n\n def _on_exception(self, exception):\n if (\n self.log_dir is not None\n and self.log_dir.is_temp\n and os.path.exists(self.log_dir.location)\n ):\n shutil.rmtree(self.log_dir.location)\n\n class FitGeneratorPatch(PatchFunction):\n \"\"\"\n NOTE: `fit_generator()` is deprecated in TF >= 2.1.0 and simply wraps `fit()`.\n To avoid unintentional creation of nested MLflow runs caused by a patched\n `fit_generator()` method calling a patched `fit()` method, we only patch\n `fit_generator()` in TF < 2.1.0.\n \"\"\"\n\n def __init__(self):\n self.log_dir = None\n\n def _patch_implementation(\n self, original, inst, *args, **kwargs\n ): # pylint: disable=arguments-differ\n unlogged_params = [\"self\", \"generator\", \"callbacks\", \"validation_data\", \"verbose\"]\n\n log_fn_args_as_params(original, args, kwargs, unlogged_params)\n\n run_id = mlflow.active_run().info.run_id\n\n with batch_metrics_logger(run_id) as metrics_logger:\n # Check if the 'callback' argument of fit() is set positionally\n if len(args) >= 5:\n # Convert the positional training function arguments to a list in order to\n # mutate the contents\n args = list(args)\n # Make a shallow copy of the preexisting callbacks to avoid permanently\n # modifying their contents for future training invocations. Introduce\n # TensorBoard & tf.keras callbacks if necessary\n callbacks = list(args[4])\n callbacks, self.log_dir = _setup_callbacks(\n callbacks, log_models, metrics_logger\n )\n # Replace the callbacks positional entry in the copied arguments and convert\n # the arguments back to tuple form for usage in the training function\n args[4] = callbacks\n args = tuple(args)\n else:\n # Make a shallow copy of the preexisting callbacks and introduce TensorBoard\n # & tf.keras callbacks if necessary\n callbacks = list(kwargs.get(\"callbacks\") or [])\n kwargs[\"callbacks\"], self.log_dir = _setup_callbacks(\n callbacks, log_models, metrics_logger\n )\n\n result = original(inst, *args, **kwargs)\n\n _flush_queue()\n mlflow.log_artifacts(local_dir=self.log_dir.location, artifact_path=\"tensorboard_logs\")\n if self.log_dir.is_temp:\n shutil.rmtree(self.log_dir.location)\n\n return result\n\n def _on_exception(self, exception):\n if (\n self.log_dir is not None\n and self.log_dir.is_temp\n and os.path.exists(self.log_dir.location)\n ):\n shutil.rmtree(self.log_dir.location)\n\n def add_event(original, self, event):\n _log_event(event)\n return original(self, event)\n\n def add_summary(original, self, *args, **kwargs):\n result = original(self, *args, **kwargs)\n _flush_queue()\n return result\n\n managed = [\n (tensorflow.estimator.Estimator, \"train\", train),\n (tensorflow.keras.Model, \"fit\", FitPatch),\n ]\n\n if Version(tensorflow.__version__) < Version(\"2.1.0\"):\n # `fit_generator()` is deprecated in TF >= 2.1.0 and simply wraps `fit()`.\n # To avoid unintentional creation of nested MLflow runs caused by a patched\n # `fit_generator()` method calling a patched `fit()` method, we only patch\n # `fit_generator()` in TF < 2.1.0\n managed.append((tensorflow.keras.Model, \"fit_generator\", FitGeneratorPatch))\n\n non_managed = [\n (EventFileWriter, \"add_event\", add_event),\n (EventFileWriterV2, \"add_event\", add_event),\n (FileWriter, \"add_summary\", add_summary),\n (tensorflow.estimator.Estimator, \"export_saved_model\", export_saved_model),\n (tensorflow.estimator.Estimator, \"export_savedmodel\", export_saved_model),\n ]\n\n # Add compat.v1 Estimator patching for versions of tensfor that are 2.0+.\n if Version(tensorflow.__version__) >= Version(\"2.0.0\"):\n old_estimator_class = tensorflow.compat.v1.estimator.Estimator\n v1_train = (old_estimator_class, \"train\", train)\n v1_export_saved_model = (old_estimator_class, \"export_saved_model\", export_saved_model)\n v1_export_savedmodel = (old_estimator_class, \"export_savedmodel\", export_saved_model)\n\n managed.append(v1_train)\n non_managed.append(v1_export_saved_model)\n non_managed.append(v1_export_savedmodel)\n\n for p in managed:\n safe_patch(FLAVOR_NAME, *p, manage_run=True)\n\n for p in non_managed:\n safe_patch(FLAVOR_NAME, *p)","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 log_results(best_model, model_name, max_features, train_score, test_score,\n score_fp):\n\n # ensure the directorys where metrics are stored are created\n if not os.path.exists(os.path.dirname(score_fp)):\n os.makedirs(os.path.dirname(score_fp), exist_ok=True)\n\n st = datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')\n with open(score_fp, 'a+') as f:\n f.write(st + '\\n')\n f.write('-' * 100 + '\\n')\n f.write('Model Run: {}\\n\\n'.format(model_name))\n f.write('Params: {}\\n\\n'.format(best_model.get_params())) \n f.write('Max features: {}\\n\\n'.format(max_features))\n f.write('Train Score: {}\\n\\n'.format(train_score))\n f.write('Test Score: {}\\n\\n'.format(test_score))","def train_logger(model_fn):\n\n @functools.wraps(model_fn)\n def wrapper(*args, **kwargs):\n timer_start = time.perf_counter()\n model = model_fn(*args, **kwargs)\n timer_end = time.perf_counter()\n\n time_stamp = time.localtime()\n model_version = MODEL_VERSION\n run_time = timer_end - timer_start\n\n log_entry = [time_stamp, MODEL_VERSION, run_time]\n\n header = \\\n ','.join(TRAIN_HEADER) \\\n if os.path.exists(CWD, LOG_PATH, LOG_FILE.format(LOG_TYPES['T'])) \\\n else False\n\n create_or_update_log(LOG_TYPES['T'], log_entry, header)\n\n print('Logging: train logger')\n\n return model\n return wrapper","def LogProgress(model, writer, test_loader, epoch, device): \n\n model.eval() \n sequential = test_loader\n sample_batched = next(iter(sequential))\n \n image = torch.Tensor(sample_batched[\"image\"]).to(device)\n depth = torch.Tensor(sample_batched[\"depth\"]).to(device)\n \n if epoch == 0:\n writer.add_image(\"Train.1.Image\", vision_utils.make_grid(image.data, nrow=6, normalize=True), epoch)\n if epoch == 0:\n writer.add_image(\"Train.2.Image\", colorize(vision_utils.make_grid(depth.data, nrow=6, normalize=False)), epoch)\n \n output = DepthNorm(model(image))\n\n writer.add_image(\"Train.3.Ours\", colorize(vision_utils.make_grid(output.data, nrow=6, normalize=False)), epoch)\n writer.add_image(\"Train.4.Diff\", colorize(vision_utils.make_grid(torch.abs(output-depth).data, nrow=6, normalize=False)), epoch)\n \n del image\n del depth\n del output","def log_model(self, model_name=\"fixmatch_model\"):\n \n assert hasattr(self, \"_mlflow\"), \"need to run track_with_mlflow() first\"\n from mlflow.keras import log_model\n log_model(self._models[\"full\"], model_name)","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 add_summary(self):\n merged = tf.summary.merge_all()\n self.file_writer = tf.summary.FileWriter(self.FLAGS.model_dir, self.session.graph)","def send_log():\n log.info(f\"UUID={UUID}\")\n log.info(f\"SPLIT={SPLIT}\")\n log.info(f\"BATCH_SIZE={BATCH_SIZE}\")\n log.info(f\"EPOCHS={EPOCHS}\")\n log.info(f\"PATIENCE={PATIENCE}\")\n log.info(f\"X_FREQ={X_FREQ}\")\n log.info(f\"LOOK_BACK={LOOK_BACK}\")\n log.info(f\"LOOK_AHEAD={LOOK_AHEAD}\")\n log.info(f\"KERNEL_SIZE={KERNEL_SIZE}\")\n log.info(f\"FILTERS={FILTERS}\")\n log.info(f\"L1L2={L1L2}\")\n log.info(f\"D1={D1}\")\n log.info(f\"D2={D2}\")\n log.info(f\"DOUT={DOUT}\")\n log.info(f\"PLOT={PLOT}\")\n log.info(f\"SHUFFLE={SHUFFLE}\")","def _print_log(self, step, data=None):\n \n # Set mode to append to log file\n mode = 'a'\n\n if self.logfile is None:\n # Increment log counter for the class. Each instance of the class generates a new log.\n self.__class__.log_no += 1\n\n # Create a log file for the instance\n # Logs will be stored in ..\\logs\\SKLearn Log <n>.txt\n self.logfile = os.path.join(os.getcwd(), 'logs', 'SKLearn Log {}.txt'.format(self.log_no))\n \n if step == 1:\n # Output log header\n output = \"\\nSKLearnForQlik Log: {0} \\n\\n\".format(time.ctime(time.time()))\n # Set mode to write new log file\n mode = 'w'\n \n elif step == 2:\n # Output the parameters\n output = \"Model Name: {0}\\n\\n\".format(self.model.name)\n output += \"Execution arguments: {0}\\n\\n\".format(self.exec_params)\n \n try:\n output += \"Scaler: {0}, missing: {1}, scale_hashed: {2}, scale_vectors: {3}\\n\".format(\\\n self.model.scaler, self.model.missing,self.model.scale_hashed, self.model.scale_vectors)\n output += \"Scaler kwargs: {0}\\n\\n\".format(self.model.scaler_kwargs)\n except AttributeError:\n output += \"scale_hashed: {0}, scale_vectors: {1}\\n\".format(self.model.scale_hashed, self.model.scale_vectors)\n\n try:\n if self.model.dim_reduction:\n output += \"Reduction: {0}\\nReduction kwargs: {1}\\n\\n\".format(self.model.reduction, self.model.dim_reduction_args)\n except AttributeError:\n pass\n \n output += \"Estimator: {0}\\nEstimator kwargs: {1}\\n\\n\".format(self.model.estimator, self.model.estimator_kwargs)\n \n elif step == 3: \n # Output the request dataframe\n output = \"REQUEST: {0} rows x cols\\nSample Data:\\n\\n\".format(self.request_df.shape)\n output += \"{0}\\n...\\n{1}\\n\\n\".format(self.request_df.head().to_string(), self.request_df.tail().to_string())\n \n elif step == 4:\n # Output the response dataframe/series\n output = \"RESPONSE: {0} rows x cols\\nSample Data:\\n\\n\".format(self.response.shape)\n output += \"{0}\\n...\\n{1}\\n\\n\".format(self.response.head().to_string(), self.response.tail().to_string())\n \n elif step == 5:\n # Print the table description if the call was made from the load script\n output = \"\\nTABLE DESCRIPTION SENT TO QLIK:\\n\\n{0} \\n\\n\".format(self.table)\n \n elif step == 6:\n # Message when model is loaded from cache\n output = \"\\nModel {0} loaded from cache.\\n\\n\".format(self.model.name)\n \n elif step == 7:\n # Message when model is loaded from disk\n output = \"\\nModel {0} loaded from disk.\\n\\n\".format(self.model.name)\n \n elif step == 8:\n # Message when cache is updated\n output = \"\\nCache updated. Models in cache:\\n{0}\\n\\n\".format([k for k,v in self.__class__.model_cache.items()])\n \n elif step == 9:\n # Output when a parameter grid is set up\n output = \"Model Name: {0}, Estimator: {1}\\n\\nGrid Search Arguments: {2}\\n\\nParameter Grid: {3}\\n\\n\".\\\n format(self.model.name, self.model.estimator, self.model.grid_search_args, self.model.param_grid)\n \n elif step == 10:\n # self.model.estimator_kwargs['architecture']\n output = \"\\nKeras architecture added to Model {0}:\\n\\n{1}\\n\\n\".format(self.model.name,\\\n self.model.architecture.to_string())\n\n elif step == 11:\n # Output after adding lag observations to input data\n output = \"Lag observations added ({0} per sample). New input shape of X is {1}.\\n\\n\".format(self.model.lags, data.shape)\n output += \"Feature Definitions:\\n{0}\\n\\n\".format(self.model.features_df.to_string())\n output += \"Sample Data:\\n{0}\\n...\\n{1}\\n\\n\".format(data.head(5).to_string(), data.tail(5).to_string())\n \n sys.stdout.write(output)\n with open(self.logfile, mode, encoding='utf-8') as f:\n f.write(output)","def summary(self):\n\t\tself.writer = tf.summary.FileWriter(\n\t\t\t\t'./graphs/AttNCF', tf.get_default_graph())\n\t\twith tf.name_scope(\"summaries\"):\n\t\t\ttf.summary.scalar('loss', self.loss)\n\t\t\tself.summary_op = tf.summary.merge_all()","def log_train_summary(step: int,\n *,\n writer: metric_writers.MetricWriter,\n train_metrics: Sequence[Dict[str, Tuple[float, int]]],\n extra_training_logs: Optional[Sequence[Dict[str,\n Any]]] = None,\n metrics_normalizer_fn: Optional[\n Callable[[Dict[str, Tuple[float, int]], str],\n Dict[str, float]]] = None,\n prefix: str = 'train',\n key_separator: str = '_') -> Dict[str, float]:\n ##### Prepare metrics:\n # Get metrics from devices:\n train_metrics = stack_forest(train_metrics)\n # Compute the sum over all examples in all batches:\n train_metrics_summary = jax.tree_map(lambda x: x.sum(), train_metrics)\n # Normalize metrics by the total number of exampels:\n metrics_normalizer_fn = metrics_normalizer_fn or normalize_metrics_summary\n train_metrics_summary = metrics_normalizer_fn(train_metrics_summary, 'train')\n\n ##### Prepare additional training logs:\n # If None, set to an empty dictionary.\n extra_training_logs = extra_training_logs or {}\n train_logs = stack_forest(extra_training_logs)\n\n # Metrics:\n writer.write_scalars(\n step, {\n key_separator.join((prefix, key)): val\n for key, val in train_metrics_summary.items()\n })\n # Additional logs:\n writer.write_scalars(step,\n {key: val.mean() for key, val in train_logs.items()})\n\n writer.flush()\n return train_metrics_summary","def model_summary_to_file(model, save_path):\n with open(save_path, 'w') as fh:\n model.summary(print_fn=lambda x: fh.write(x + \"\\n\"))","def test_01_train(self):\n today = date.today()\n log_file = os.path.join(LOG_DIR, \"{}-train-{}-{}.log\".format(LOG_PREFIX, today.year, today.month))\n if os.path.exists(log_file):\n os.remove(log_file)\n \n ## update the log\n country = 'india'\n date_range = ('2017-11-29', '2019-05-24')\n metric = {'rmse':0.5}\n runtime = \"00:00:01\"\n model_version = 0.1\n model_version_note = \"test model\"\n \n update_train_log(country, date_range, metric, runtime,\n model_version, model_version_note, test=True, prefix=LOG_PREFIX)\n\n self.assertTrue(os.path.exists(log_file))","def create_summary_statistics(forward_accuracy, backward_accuracy, merged_accuracy):\n summary_statistics = open(f'summary_statistics.txt', 'a')\n summary_statistics.write(f'The forward model has an accuracy of: {forward_accuracy}\\n')\n summary_statistics.write(f'The backward model has an accuracy of: {backward_accuracy}\\n')\n summary_statistics.write(f'The merged model has an accuracy of: {merged_accuracy}\\n')\n summary_statistics.close()","def print_statistics(self) -> None:\n e = self.current_epoch\n if len(self.loss_history[\"test_loss\"]) > 0:\n template = 'Epoch: {} Training loss: {:.4f}, Test loss: {:.4f}'\n print(template.format(e, self.loss_history[\"training_loss\"][-1],\n self.loss_history[\"test_loss\"][-1]))\n else:\n template = 'Epoch: {} Training loss: {:.4f}'\n print(template.format(e, self.loss_history[\"training_loss\"][-1]))","def summary(self):\n if self.model_type == 2:\n if self.std is None:\n print(\n dedent(\n f\"\"\"\\\n Oaxaca-Blinder Two-fold Effects\n Unexplained Effect: {self.params[0]:.5f}\n Explained Effect: {self.params[1]:.5f}\n Gap: {self.params[2]:.5f}\"\"\"\n )\n )\n else:\n print(\n dedent(\n \"\"\"\\\n Oaxaca-Blinder Two-fold Effects\n Unexplained Effect: {:.5f}\n Unexplained Standard Error: {:.5f}\n Explained Effect: {:.5f}\n Explained Standard Error: {:.5f}\n Gap: {:.5f}\"\"\".format(\n self.params[0],\n self.std[0],\n self.params[1],\n self.std[1],\n self.params[2],\n )\n )\n )\n if self.model_type == 3:\n if self.std is None:\n print(\n dedent(\n f\"\"\"\\\n Oaxaca-Blinder Three-fold Effects\n Endowment Effect: {self.params[0]:.5f}\n Coefficient Effect: {self.params[1]:.5f}\n Interaction Effect: {self.params[2]:.5f}\n Gap: {self.params[3]:.5f}\"\"\"\n )\n )\n else:\n print(\n dedent(\n f\"\"\"\\\n Oaxaca-Blinder Three-fold Effects\n Endowment Effect: {self.params[0]:.5f}\n Endowment Standard Error: {self.std[0]:.5f}\n Coefficient Effect: {self.params[1]:.5f}\n Coefficient Standard Error: {self.std[1]:.5f}\n Interaction Effect: {self.params[2]:.5f}\n Interaction Standard Error: {self.std[2]:.5f}\n Gap: {self.params[3]:.5f}\"\"\"\n )\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())","def summary(self, *args, parameters_to_show=4, **kwargs):\n string = super(MultiAnalysisRead, self).summary(\n show_parameters=False, show_nsamples=False\n )\n string += \"analyses: {}\\n\\n\".format(\", \".join(self.labels))\n for num, label in enumerate(self.labels):\n string += \"{}\\n\".format(label)\n string += \"-\" * len(label) + \"\\n\"\n string += \"description: {}\\n\".format(self.description[label])\n string += \"nsamples: {}\\n\".format(len(self.samples[num]))\n string += \"parameters: {}\\n\\n\".format(\n self._parameter_summary(\n self.parameters[num], parameters_to_show=parameters_to_show\n )\n )\n return string[:-2]","def printModelAndTime(self):\n import time\n self._reporter.writeOutput(\"Model name = \" + self.modelName + '\\n' +\n \"Output directory = \" + self._outputDir_ + '\\n' +\n \"Time = \" + time.asctime() + '\\n')\n return","def on_train_begin(self, logs=None):\n pass","def print_layer_trainable(model_name):\n\n print('trainable : layer name')\n print('- '*30)\n for layer in model_name.layers:\n # if layer.trainable:\n print(\"{0}:\\t{1}\".format(layer.trainable, layer.name))\n \n return","def write_info(model, dataset, batch_size, learning_rate, epochs):\n file_info = open(os.path.join(model['model_dir'], 'info.json'), 'w')\n dic_info = {\n 'cameras': dataset['num_cameras'],\n 'dataset': dataset['dataset_dir'],\n 'max_demos': dataset['max_demos'],\n 'resume': model['resume'],\n 'epochs': epochs,\n 'learning_rate': learning_rate,\n 'batch_size': batch_size\n }\n file_info.write(json.dumps(dic_info, cls=NumpyEncoder))\n file_info.close()","def show_learning_stats(track, train_loss, train_acc, valid_acc, test_acc):\n\n if track[\"valid\"] and track[\"test\"]:\n print(\"Train loss: {:.4f} -- Train acc: {:.4f} -- Val acc: {:.4f} -- Test acc: {:.4f}\".format(\n train_loss, train_acc, valid_acc, test_acc))\n\n if track[\"valid\"] and not track[\"test\"]:\n print(\"Train loss: {:.4f} -- Train acc: {:.4f} -- Val acc: {:.4f}\".format(\n train_loss, train_acc, valid_acc))\n\n if not track[\"valid\"] and track[\"test\"]:\n print(\"Train loss: {:.4f} -- Train acc: {:.4f} -- Test acc: {:.4f}\".format(\n train_loss, train_acc, test_acc))\n\n if not track[\"valid\"] and not track[\"test\"]:\n print(\"Train loss: {:.4f} -- Train acc: {:.4f} \".format(\n train_loss, train_acc))","def stdout_logging_callback(epoch_n, batch_n, model, optimizer):\n if not batch_n % 100:\n logger.debug(f\"Epoch {epoch_n}, batch {batch_n}\")","def log_step(\n metric_dict={},\n mode='train',\n writer=None,\n global_step=0,\n elapsed_eta=None,\n training_speed=None\n):\n log_msg = '[{mode}] step: {step}'\n log_msg = log_msg.format(\n mode=mode,\n step=global_step,\n )\n for key, value in metric_dict.items():\n log_msg += ' - {}: {}'.format(key, round(value, 4))\n\n # Write to tensorboard\n if writer is not None:\n for key, value in metric_dict.items():\n writer.add_scalar(key, value, global_step=global_step)\n\n if elapsed_eta is not None:\n log_msg += ' - elapsed: {} - eta: {}'.format(\n datetime.timedelta(seconds=int(elapsed_eta[0])),\n datetime.timedelta(seconds=int(elapsed_eta[1]))\n )\n if writer is not None:\n writer.add_scalar('eta', elapsed_eta[1], global_step=global_step)\n\n if training_speed is not None:\n log_msg += ' - step/sec: {:.4f}'.format(training_speed)\n if writer is not None:\n writer.add_scalar(\n 'step/sec', training_speed, global_step=global_step)\n\n logger.info(log_msg)","def get_summary(self):\n return self.model.summary()"],"string":"[\n \"def summary(self):\\n\\n self.model.summary(print_fn=lambda x: logging.info(x))\",\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_summary(self):\\n self.model.summary()\",\n \"def log_model_info(log_file: str, full_train_state: train_state_lib.TrainState,\\n partitioner: partitioning.BasePartitioner):\\n # Only write logs on host 0.\\n if jax.process_index() != 0:\\n return\\n\\n state_dict = full_train_state.state_dict()\\n param_state_dict = state_dict['target']\\n total_num_params = jax.tree_util.tree_reduce(\\n np.add, jax.tree_map(np.size, param_state_dict))\\n\\n param_logical_axes = partitioner.get_logical_axes(\\n full_train_state).state_dict()['target']\\n\\n param_mesh_axes = jax.tree_map(\\n lambda x: tuple(x) if x is not None else None,\\n partitioner.get_mesh_axes(full_train_state).state_dict()['target'])\\n\\n def _log_info_and_write_to_file(writer, format_str, *args):\\n logging.info(format_str, *args)\\n writer.write(format_str % args + '\\\\n')\\n\\n with gfile.GFile(log_file, 'w') as writer:\\n\\n # Log params\\n def _log_param(name: str, arr: np.ndarray,\\n logical_axes: Optional[partitioning.AxisNames],\\n mesh_axes: Optional[partitioning.PartitionSpec]):\\n if logical_axes is None:\\n shape_str = str(arr.shape)\\n else:\\n assert len(logical_axes) == len(arr.shape)\\n shape_str = '({})'.format(', '.join(\\n f'{name}={dimension}'\\n for name, dimension in zip(logical_axes, arr.shape)))\\n _log_info_and_write_to_file(\\n writer, 'Variable %-80s size %-12s shape %-40s partition spec %s',\\n name, arr.size, shape_str, mesh_axes)\\n\\n jax.tree_map(_log_param, state_utils.get_name_tree(param_state_dict),\\n param_state_dict, param_logical_axes, param_mesh_axes)\\n\\n _log_info_and_write_to_file(writer, 'Total number of parameters: %d',\\n total_num_params)\\n\\n # Add a blank line between params and states.\\n _log_info_and_write_to_file(writer, '')\\n\\n # Log states\\n def _log_state(name, arr):\\n if arr is None:\\n _log_info_and_write_to_file(writer, 'State %-80s None', name)\\n else:\\n _log_info_and_write_to_file(writer,\\n 'State %-80s size %-12s shape %s', name,\\n arr.size, arr.shape)\\n\\n jax.tree_map(_log_state, state_utils.get_name_tree(state_dict['state']),\\n state_dict['state'])\",\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 summary(self) -> None:\\n print(\\\"Model manager summary:\\\")\\n print(\\\"Preprocessor:\\\")\\n print(self.preprocessor)\\n print(\\\"Model summary:\\\")\\n self.model.summary()\\n print(\\\"Postprocessor:\\\")\\n print(self.postprocessor)\",\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_summary(self):\\n print(\\\"Word Level\\\")\\n self.model_word.summary()\\n \\n print(\\\"Sent Level\\\")\\n self.model_sent.summary()\\n\\n print(\\\"Doc Level\\\")\\n self.model.summary()\",\n \"def summary(self):\\r\\n print(self.model.summary())\",\n \"def summary(self):\\n print(self.model.summary())\",\n \"def logging_init(model, graph):\\n # Add ops to record summaries for loss and accuracy...\\n train_loss = tf.summary.scalar(\\\"train_loss\\\", model.loss)\\n train_accuracy = tf.summary.scalar(\\\"train_accuracy\\\", model.accuracy)\\n # ...then merge these ops into one single op so that they easily be run\\n # together\\n train_summary_ops = tf.summary.merge([train_loss, train_accuracy])\\n # Same ops, but with different names, so that train/test results show up\\n # separately in TensorBoard\\n test_loss = tf.summary.scalar(\\\"test_loss\\\", model.loss)\\n test_accuracy = tf.summary.scalar(\\\"test_accuracy\\\", model.accuracy)\\n test_summary_ops = tf.summary.merge([test_loss, test_accuracy])\\n\\n timestamp = int(time.time())\\n run_log_dir = os.path.join(LOGS_DIR, str(timestamp))\\n os.makedirs(run_log_dir)\\n # (this step also writes the graph to the events file so that\\n # it shows up in TensorBoard)\\n summary_writer = tf.summary.FileWriter(run_log_dir, graph)\\n\\n return train_summary_ops, test_summary_ops, summary_writer\",\n \"def create_log(self):\\n self.model.graph.get_stats()\\n out = self.model.graph.summary\\n out[\\\"training_error\\\"] = zip(self.train_it, self.train_err)\\n out[\\\"validation_error\\\"] = zip(self.validation_it, self.validation_err)\\n with open(self.log, \\\"w\\\") as f:\\n f.write(json.dumps(out, default=defaultencode))\",\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 summary(self):\\n self.model.summary()\",\n \"def model_stats(opt, epoch, model):\\n log = rlog.getLogger(opt.experiment + \\\".model\\\")\\n if hasattr(opt, \\\"log\\\") and opt.log.detailed:\\n # log histogram also\\n assert isinstance(\\n model, SVIModel\\n ), \\\"This stat only makes sense for SVI models.\\\"\\n for mu, std in zip(model.mu(), model.std()):\\n log.put(mu=mu, std=std)\\n log.trace(step=epoch, **model.summarize())\\n log.reset()\",\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_info(self):\\r\\n self.system.print_to_log(\\r\\n f\\\"{self.__class__.__name__} model: Infection probability: {self.p}, Infectious period: {self.i}, Recovery period: {self.r}.\\\")\",\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 show_model_summary(self):\\n\\t\\treturn self.model.summary()\",\n \"def log_best_performer(self) -> None:\\n best = self.get_highest_accuracy()\\n self.logger.info(f\\\"\\\\n\\\\nThe model with the highest accuracy {best[0]} has the following characteristics: \\\\n\\\")\\n for k, v in best[1].items():\\n if k != 'best_performer':\\n self.logger.info(f\\\"{k} : {v}\\\")\\n else:\\n self.logger.info(f\\\"Best Accuracy: {v['Accuracy']}\\\")\\n self.logger.info(\\\"Features used: \\\")\\n for f in v['Labels']:\\n self.logger.info(f)\\n for nw, w in v['Vars'].items():\\n self.logger.info(f\\\"{nw}: {w}\\\")\",\n \"def logging(self, function):\\n avg_nms_time_per_step = sum(self.nms_times)/len(self.nms_times)\\n avg_total_time_per_step = sum(self.total_times)/len(self.total_times)\\n\\n avg_min_latency = [x[0] for x in self.inference_times]\\n avg_max_latency = [x[1] for x in self.inference_times]\\n avg_latency = [x[2] for x in self.inference_times]\\n\\n function(\\\"Inference stats: image size {}x{}, batches per step {}, batch size {}, {} steps\\\".format(\\n self.cfg.model.image_size, self.cfg.model.image_size, self.cfg.ipuopts.batches_per_step, self.cfg.model.micro_batch_size, len(self.total_times)\\n ))\\n function(\\\"--------------------------------------------------\\\")\\n function(\\\"Inference\\\")\\n function(\\\"Average Min Latency per Batch: {:.3f} ms\\\".format(1000 * sum(avg_min_latency)/len(self.inference_times)))\\n function(\\\"Average Max Latency per Batch: {:.3f} ms\\\".format(1000 * sum(avg_max_latency)/len(self.inference_times)))\\n function(\\\"Average Latency per Batch: {:.3f} ms\\\".format(1000 * sum(avg_latency)/len(self.inference_times)))\\n function(\\\"Average Inference Throughput: {:.3f} img/s\\\".format(sum(self.inference_throughputs)/len(self.inference_throughputs)))\\n function(\\\"--------------------------------------------------\\\")\\n # TODO remove the NMS and end-to-end time report once NMS is on device\\n function(\\\"End-to-end\\\")\\n function(\\\"Average NMS Latency per Batch: {:.3f} ms\\\".format(1000 * avg_nms_time_per_step/self.cfg.ipuopts.batches_per_step))\\n function(\\\"Average End-to-end Latency per Batch: {:.3f} ms\\\".format(1000 * avg_total_time_per_step/self.cfg.ipuopts.batches_per_step))\\n function(\\\"End-to-end Throughput: {:.3f} img/s\\\".format(sum(self.total_throughputs)/len(self.total_throughputs)))\\n function(\\\"==================================================\\\")\\n\\n if self.cfg.eval.metrics:\\n self.compute_and_print_eval_metrics()\",\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 on_train_begin(self, logs=None):\\n f = open(self.log_file_path, \\\"a\\\")\\n f.write(f\\\"{'=' * 5}{self.model_name}({self.hp_log_title}){'=' * 5}\\\\n\\\")\\n f.close()\",\n \"def save_summary(model, model_name, stage_no):\\n stringlist = []\\n model.summary(print_fn=lambda x: stringlist.append(x))\\n short_model_summary = \\\"\\\\n\\\".join(stringlist)\\n \\n with open(eval_path+\\\"{}_model_summary_stage_{}.txt\\\".format(model_name, stage_no), \\\"w\\\") as text_file:\\n print(short_model_summary, file=text_file)\",\n \"def initialize_summary(self):\\n if self.need_logs:\\n self.summary_writer = tf.summary.create_file_writer(self.log_dir)\\n if self.verbose > 0:\\n full_log_path = os.path.abspath(self.log_dir)\\n print('Initialize logs, use: \\\\ntensorboard --logdir={}'.format(full_log_path))\",\n \"def output_summary(self, v, vhat, sk, logged_matrics, train_dataset_label, val_dataset_label, summary_folder_path):\\n\\n mse = np.sum((v-vhat)**2)/len(v)\\n train_loss = logged_matrics[\\\"train_loss\\\"]\\n\\n k = np.sum(p.numel() for p in self.parameters())\\n\\n numOfSamples = len(sk)\\n aic = 2*k + numOfSamples*np.log(mse) + numOfSamples*(1+np.log(2*np.pi))\\n\\n summary_file = os.path.join(summary_folder_path, \\\"model_summary.txt\\\")\\n if not os.path.isfile(summary_file):\\n print(\\\"Created file \\\"+summary_file)\\n with open(summary_file, \\\"w\\\") as output:\\n output.write(\\n \\\"Model Train_dataset_label Val_dataset_label Train_loss Test_loss AIC\\\\n\\\")\\n else:\\n print(summary_file +\\n \\\" exists, model summary will be attached to the end of this file.\\\")\\n\\n with open(summary_file, \\\"a\\\") as output:\\n model_name = self.version\\n output.write(model_name + \\\" \\\" + train_dataset_label + \\\" \\\" +\\n val_dataset_label + \\\" %f %f %f\\\\n\\\" % (train_loss, mse, aic))\\n\\n\\n plt.scatter(sk, v, c=\\\"blue\\\", s=2, label=\\\"true\\\")\\n plt.scatter(sk, vhat, c=\\\"red\\\", s=2, label=\\\"predict\\\")\\n plt.legend()\\n plt.xlabel(\\\"sk\\\")\\n plt.ylabel(\\\"v\\\")\\n\\n plt.savefig(os.path.join(summary_folder_path, \\\"plots\\\", model_name+\\\".png\\\"))\\n plt.show()\\n\\n np.savetxt(os.path.join(summary_folder_path, \\\"model_prediction\\\", model_name+\\\"_prediction.txt\\\"), np.column_stack((sk, v, vhat)), header=\\\"sk v vhat\\\", fmt='%.8f')\\n\\n\\n print(\\\"Plot saved as\\\", os.path.join(summary_folder_path, \\\"plots\\\", model_name+\\\".png\\\"))\\n print(\\\"Model prediction saved as\\\", os.path.join(summary_folder_path, \\\"model_prediction\\\", model_name+\\\"_prediction.txt\\\"))\",\n \"def summary_info(self):\\n return [('model_architecture', self.model_architecture),\\n ('input_size', self.input_size),\\n ('output_size', self.output_size),\\n ('hidden_layers', self.hidden_layers),\\n ('learn_rate', self.learn_rate),\\n ('drop_p', self.drop_p),\\n ('current_epoch', self.model.current_epoch)]\",\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 test_summaries(self):\\n try:\\n ans = str(self.model)\\n except:\\n assert False, \\\"Model __repr__ failed.\\\"\\n\\n try:\\n print(self.model)\\n except:\\n assert False, \\\"Model print failed.\\\"\\n\\n try:\\n self.model.summary()\\n except:\\n assert False, \\\"Model summary failed.\\\"\",\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 execute_summary(self, step):\\n with self.summary_writer.as_default():\\n tf.summary.scalar('bias', self.core.fmlayer.b, step=step)\\n tf.summary.scalar('regularization_penalty', self.regularization, step=step)\\n tf.summary.scalar('loss', self.reduced_loss, step=step)\\n tf.summary.scalar('target', self.target, step=step)\",\n \"def log_trainable_variables(self):\\n var_names = list(self.trainable_variables.keys())\\n self.logger.log_trainable_variables(var_names)\",\n \"def on_train_begin(self, logs):\\n self.train_start = timeit.default_timer()\\n self.metrics_names = self.model.metrics_names\\n print('Training for {} steps ...'.format(self.params['nb_steps']))\",\n \"def get_model_info(y_test, model_name, model_parameters, model_preprocessing, sequence_origin, primers_origin,\\n taxonomy_level, selected_primer, test_size, logger) -> int:\\n\\n # Global information on the model\\n logger.log(title='Parameter information for {}'.format(model_name))\\n # Data Origins\\n logger.log(subtitle='Data Origins')\\n logger.log(text='Sequence origin: {}'.format(sequence_origin))\\n logger.log(text='Primers origin: {}'.format(primers_origin))\\n # Chosen levels for classification\\n logger.log(subtitle='Chosen HyperVariable Region and Taxonomy Rank')\\n logger.log(text='HyperVariable Region: {}'.format(str(selected_primer)))\\n logger.log(text='Taxonomy Rank: {}'.format(str(taxonomy_level)))\\n # Applied Preprocessing\\n logger.log(subtitle='Preprocessing')\\n logger.log(text='Preprocessing description: ' + model_preprocessing)\\n # Model parameters\\n logger.log(subtitle='Model parameters')\\n logger.log(text='Parameter dict: {}'.format(str(model_parameters)))\\n logger.log(text='Size of test set: {}'.format(len(y_test)))\\n logger.log(text='Part of test size compared to total: {}'.format(test_size))\\n\\n return len(y_test)\",\n \"def log_training_results(engine: Engine):\\n train_evaluator.run(self.train_dl)\\n metrics: Dict[str, float] = train_evaluator.state.metrics\\n avg_accuracy: float = metrics['accuracy']\\n avg_bce: float = metrics['bce']\\n pbar.log_message(\\n f'Training Results - Epoch: {engine.state.epoch} Avg accuracy: {avg_accuracy:.4f} Avg loss: {avg_bce:.4f}')\",\n \"def _setup_summaries(self, sess):\\n # Output directory for models and summaries\\n\\n\\n print(\\\"Writing to {}\\\\n\\\".format(os.path.abspath(self._log_dir)))\\n\\n train_summary_dir = os.path.join(self._log_dir, \\\"summaries\\\", \\\"train\\\")\\n self._train_summary_writer = tf.summary.FileWriter(train_summary_dir, sess.graph)\\n\\n val_summary_dir = os.path.join(self._log_dir, \\\"summaries\\\", \\\"validation\\\")\\n self._val_summary_writer = tf.summary.FileWriter(val_summary_dir, sess.graph)\\n\\n # Model checkpoints\\n # Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it\\n self.checkpoint_dir = os.path.abspath(os.path.join(self._save_dir, \\\"checkpoints/\\\"))\\n\\n if not os.path.exists(self.checkpoint_dir):\\n os.makedirs(self.checkpoint_dir)\\n\\n self._saver = tf.train.Saver(max_to_keep=10) # Save model after each epoch\\n\\n self.train_summary_op = tf.summary.merge(self._train_summaries)\\n self.val_summary_op = tf.summary.merge(self._val_summaries)\\n\\n print(\\\"--------------------------------------------------\\\")\\n print(\\\"\\\\ntensorboard --logdir {}\\\".format(os.path.abspath(self._log_dir)))\\n print(\\\"\\\\ntensorboard --logdir {} --port 6007\\\".format(os.path.abspath(self.checkpoint_dir)))\\n print(\\\"--------------------------------------------------\\\")\",\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 _summary(self):\\n trainable_variable = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\\n for var in trainable_variable:\\n tf.summary.histogram(var.op.name, var)\\n\\n self.merged_summary_op = tf.summary.merge_all()\",\n \"def log_output_data(self):\\r\\n with tf.name_scope('model_output'):\\r\\n for i in range(self.action_handler.get_number_actions()):\\r\\n variable_name = str(self.action_handler.action_list_names[i])\\r\\n tf.summary.histogram(variable_name + '_output', self.actor_last_row_layer[i])\",\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 summary(self):\\n\\n print(\\\"input label:\\\", self.__input_label)\\n print(\\\"target label:\\\", self.__target_label)\\n print(\\\"denoising label:\\\", self.denoising_label)\\n print(\\\"contains a successful DE:\\\", self.is_successful())\",\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_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 print_summary(self):\\n self.network.print_summary()\",\n \"def training_info(self):\\n pass\",\n \"def on_train_begin(self, logs):\\n print(f\\\"Testing for {self.params['nb_episodes']} episodes ...\\\")\",\n \"def _log_weights(self, epoch):\\r\\n writer = self._get_writer(self._train_run_name)\\r\\n with context.eager_mode(), \\\\\\r\\n writer.as_default(), \\\\\\r\\n summary_ops_v2.always_record_summaries():\\r\\n for layer in self.model.layers:\\r\\n for weight in layer.weights:\\r\\n weight_name = weight.name.replace(':', '_')\\r\\n with ops.init_scope():\\r\\n weight = K.get_value(weight)\\r\\n summary_ops_v2.histogram(weight_name, weight, step=epoch)\\r\\n if self.write_images:\\r\\n self._log_weight_as_image(weight, weight_name, epoch)\\r\\n writer.flush()\",\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 write_training_summaries(self):\\n for metric, epochs in self._training_summaries.items():\\n self._write_scalar_to_tensorboard(\\n name=f\\\"{self._Sections.SUMMARY}/training_{metric}\\\",\\n value=epochs[-1],\\n step=self._epochs,\\n )\",\n \"def summary(self):\\n return self.model.summary()\",\n \"def print_summary(self, print_level = 0):\\n\\n print(\\\"==========================\\\")\\n print(\\\"= FUNtoFEM model summary =\\\")\\n print(\\\"==========================\\\")\\n print(\\\"Model name:\\\", self.name)\\n print(\\\"Number of bodies:\\\", len(self.bodies))\\n print(\\\"Number of scenarios:\\\", len(self.scenarios))\\n print(\\\" \\\")\\n print(\\\"------------------\\\")\\n print(\\\"| Bodies summary |\\\")\\n print(\\\"------------------\\\")\\n for body in self.bodies:\\n print(\\\"Body:\\\", body.id, body.name)\\n print(\\\" coupling group:\\\", body.group)\\n print(\\\" transfer scheme:\\\", type(body.transfer))\\n print(\\\" shape parameteration:\\\", type(body.shape))\\n for vartype in body.variables:\\n print(' variable type:', vartype)\\n print(' number of ', vartype, ' variables:', len(body.variables[vartype]))\\n if print_level >= 0:\\n for var in body.variables[vartype]:\\n print(' variable:', var.name, ', active?', var.active,', coupled?', var.coupled)\\n print(' value and bounds:', var.value, var.lower, var.upper)\\n\\n print(\\\" \\\")\\n print(\\\"--------------------\\\")\\n print(\\\"| Scenario summary |\\\")\\n print(\\\"--------------------\\\")\\n for scenario in self.scenarios:\\n print(\\\"scenario:\\\", scenario.id, scenario.name)\\n print(\\\" coupling group:\\\", scenario.group)\\n print(\\\" steps:\\\", scenario.steps)\\n print(\\\" steady?:\\\", scenario.steady)\\n for func in scenario.functions:\\n print(' function:', func.name, ', analysis_type:', func.analysis_type)\\n print(' adjoint?', func.adjoint)\\n if not scenario.steady:\\n print(' time range', func.start, ',', func.stop)\\n print(' averaging', func.averaging)\\n\\n\\n for vartype in scenario.variables:\\n print(' variable type:', vartype)\\n print(' number of ', vartype, ' variables:', len(scenario.variables[vartype]))\\n if print_level >= 0:\\n for var in scenario.variables[vartype]:\\n print(' variable:', var.id, var.name, ', active?', var.active,', coupled?', var.coupled)\\n print(' value and bounds:', var.value, var.lower, var.upper)\",\n \"def test_get_summary_with_model(self):\\n\\t\\t\\n\\t\\tdescription = self.watcher.describe(model=self.model)\\n\\t\\tself.assertEqual(11, len(description))\\n\\t\\t\\n\\t\\t\\n\\t\\tdetails = self.watcher.analyze(model=self.model, layers=[self.second_layer])\\n\\t\\treturned_summary = self.watcher.get_summary(details)\\n\\t\\t\\n\\t\\tprint(returned_summary)\\n\\t\\t\\n\\t\\tsaved_summary = self.watcher.get_summary()\\n\\t\\tself.assertEqual(returned_summary, saved_summary)\",\n \"def log_info(self, logger, opt_loc=''):\\n if len(np.unique(self._lr)) == 1:\\n logger.info('Using %s %s optimizer with lr = %.5f.' % \\\\\\n (self.name, opt_loc, self._lr[0]))\\n else:\\n logger.info('Using %s %s optimizer with:' % (self.name, opt_loc))\\n for forward_opt in self._optimizer_list:\\n assert len(forward_opt.param_groups) == 1\\n lr = forward_opt.param_groups[0]['lr']\\n shapes = str([list(pm.shape) for pm in \\\\\\n forward_opt.param_groups[0]['params']])\\n logger.info(' lr = %.3f for params with shape %s.' % \\\\\\n (lr, shapes[1:-1]))\",\n \"def _compute_statistics(self):\\n # log to file\\n output_dir = self.params['output_dir']\\n if not os.path.exists(output_dir):\\n os.mkdir(output_dir)\\n output_dir = os.path.join(output_dir, 'statistics.log')\\n log = logging.getLogger('tensorflow')\\n handle = logging.FileHandler(output_dir)\\n log.addHandler(handle)\\n\\n # FLOPS\\n encoder_flops, decoder_flops = 0, 0\\n encoder_count, decoder_count = 0, 0\\n graph = tf.get_default_graph()\\n for operation in graph.get_operations():\\n flops = ops.get_stats_for_node_def(graph, operation.node_def,\\n 'flops').value\\n if flops is None:\\n continue\\n if operation.name.startswith('model/encoder'):\\n # encoder\\n encoder_flops += flops\\n encoder_count += 1\\n tf.logging.info('encoder operation %s : %d', operation.name, flops)\\n elif operation.name.startswith('model/decoder'):\\n # decoder\\n decoder_flops += flops\\n decoder_count += 1\\n tf.logging.info('decoder operation %s : %d', operation.name, flops)\\n else:\\n # gradient\\n pass\\n tf.logging.info('flops of %d encoder tensor: %d',\\n encoder_count, encoder_flops)\\n tf.logging.info('flops of %d decoder tensor: %d',\\n decoder_count, decoder_flops)\\n tf.logging.info('flops of total %d tensor: %d',\\n encoder_count + decoder_count,\\n encoder_flops + decoder_flops)\\n # parameters\\n encoder_parameters, decoder_parameters = 0, 0\\n encoder_count, decoder_count = 0, 0\\n for var in tf.trainable_variables():\\n parameters = np.prod(var.get_shape().as_list())\\n if var.name.startswith('model/encoder'):\\n # encoder\\n encoder_parameters += parameters\\n encoder_count += 1\\n tf.logging.info('encoder variable %s : %d', var.name, parameters)\\n elif var.name.startswith('model/decoder'):\\n # decoder\\n decoder_parameters += parameters\\n decoder_count += 1\\n tf.logging.info('decoder variable %s : %d', var.name, parameters)\\n\\n tf.logging.info('parameters of %d encoder tensor: %d',\\n encoder_count, encoder_parameters)\\n tf.logging.info('parameters of %d decoder tensor: %d',\\n decoder_count, decoder_parameters)\\n tf.logging.info('parameters of total %d tensor: %d',\\n encoder_count + decoder_count,\\n encoder_parameters + decoder_parameters)\\n # disable log to file\\n log.removeHandler(handle)\",\n \"def log_hyperparameters(\\n cfg: DictConfig,\\n model: pl.LightningModule,\\n trainer: pl.Trainer,\\n) -> None:\\n hparams = OmegaConf.to_container(cfg, resolve=True)\\n\\n # save number of model parameters\\n hparams[f\\\"{STATS_KEY}/params_total\\\"] = sum(p.numel() for p in model.parameters())\\n hparams[f\\\"{STATS_KEY}/params_trainable\\\"] = sum(\\n p.numel() for p in model.parameters() if p.requires_grad\\n )\\n hparams[f\\\"{STATS_KEY}/params_not_trainable\\\"] = sum(\\n p.numel() for p in model.parameters() if not p.requires_grad\\n )\\n\\n # send hparams to all loggers\\n trainer.logger.log_hyperparams(hparams)\\n\\n # disable logging any more hyperparameters for all loggers\\n # (this is just a trick to prevent trainer from logging hparams of model, since we already did that above)\\n trainer.logger.log_hyperparams = lambda params: None\",\n \"def summary(self):\\r\\n self.base.summary()\\r\\n self.extra_layers.summary()\\r\\n self.detector.summary()\",\n \"def summary(self):\\n for i,layer in enumerate(self.chain):\\n x = Input([2])\\n y = layer.forward(x)\\n Model(x,y,name=f'layer_{i}_summary').summary()\",\n \"def _log_metrics(\\n self,\\n train_writer: SummaryWriter,\\n val_writer: SummaryWriter,\\n timestamped_save_dir: Path,\\n train_metrics: _Metrics,\\n step: int,\\n ) -> None:\\n if len(self.val_loader) > 0:\\n val_metrics, val_img, val_gt, val_pred = self._get_val_metrics()\\n if val_metrics.accuracy > self.best_acc:\\n self.best_acc = val_metrics.accuracy\\n self.save_weights(timestamped_save_dir, True)\\n\\n for key in vars(train_metrics):\\n if key == \\\"class_loss\\\":\\n tag = \\\"losses/classification\\\"\\n elif key in {\\\"shape_loss\\\", \\\"total_loss\\\"}:\\n continue\\n else:\\n tag = f\\\"metrics/{key}\\\"\\n\\n train_writer.add_scalar(tag, getattr(train_metrics, key), step)\\n if len(self.val_loader) > 0:\\n val_writer.add_scalar(tag, getattr(val_metrics, key), step)\\n\\n reg_loss = self._get_l2_reg()\\n train_writer.add_scalar(\\\"losses/regularization\\\", reg_loss, step)\\n train_writer.add_scalar(\\\"losses/shape\\\", train_metrics.shape_loss, step)\\n train_writer.add_scalar(\\n \\\"losses/total\\\",\\n train_metrics.total_loss + self.config.weight_decay * reg_loss,\\n step,\\n )\\n\\n # Log a histogram for each tensor parameter in the model, to\\n # see if a parameter is training stably or not\\n for name, value in self.model.state_dict().items():\\n train_writer.add_histogram(name, value, step)\\n\\n # Log the validation images for easy visualization\\n if len(self.val_loader) > 0:\\n val_writer.add_images(\\\"input\\\", val_img, step)\\n val_writer.add_images(\\\"ground_truth\\\", val_gt, step)\\n val_writer.add_images(\\\"prediction\\\", val_pred, step)\",\n \"def _logging(self):\\n msgs = []\\n # patch to log stdout spawned processes of dataloader\\n logger = init_logger()\\n for ds_name, ds_count in self._counts.items():\\n msgs.append(f\\\"\\\\t\\\\t\\\\t* {ds_name}: {ds_count}\\\")\\n logger.info(\\\"Weighted corpora loaded so far:\\\\n\\\" + \\\"\\\\n\\\".join(msgs))\",\n \"def build_summary(self):\\n assert self.mode==\\\"train\\\"\\n\\n for var in tf.trainable_variables():\\n with tf.name_scope(var.name[:var.name.find(\\\":\\\")]):\\n with tf.name_scope(\\\"values\\\"):\\n self.variable_summary(var)\\n\\n for g, var in zip(self.gs, self.g_vars):\\n with tf.name_scope(var.name[:var.name.find(\\\":\\\")]):\\n with tf.name_scope(\\\"gradients\\\"):\\n self.variable_summary(g)\\n\\n with tf.name_scope(\\\"cross_entropies\\\"):\\n self.variable_summary(self.cross_entropies)\\n\\n with tf.name_scope(\\\"attention\\\"):\\n self.variable_summary(self.sum_alpha) \\n\\n with tf.name_scope(\\\"scores\\\"):\\n self.variable_summary(self.scores) \\n\\n tf.summary.scalar(\\\"num_correct_words\\\", self.num_correct_words)\\n\\n tf.summary.scalar(\\\"cross_entropy_loss\\\", self.cross_entropy_loss)\\n tf.summary.scalar(\\\"attention_loss\\\", self.attention_loss)\\n tf.summary.scalar(\\\"l2_loss\\\", self.l2_loss)\\n tf.summary.scalar(\\\"loss\\\", self.loss)\\n \\n self.summary = tf.summary.merge_all()\",\n \"def on_train_begin(self, logs=None):\",\n \"def on_train_begin(self, logs=None):\",\n \"def print_network(self):\\n #plot_model(self.model, to_file='model.png', show_shapes=True)\\n logging.info(\\\"\\\")\\n logging.info(self.network)\\n logging.info(\\\"Network accuracy: %.2f%%\\\" % (self.accuracy * 100))\\n logging.info(\\\"Network loss: %.2f%%\\\" % (self.loss))\",\n \"def logging_summaries(\\n summary_writer: tf.contrib.summary.SummaryWriter, logged: Dict\\n) -> None:\\n\\n with summary_writer.as_default(), tf.contrib.summary.always_record_summaries():\\n tf.contrib.summary.image(\\\"generated\\\", logged[\\\"generated_data\\\"])\\n tf.contrib.summary.image(\\\"real\\\", logged[\\\"real_data\\\"])\\n tf.contrib.summary.scalar(\\\"generator/loss\\\", logged[\\\"gen_loss\\\"])\\n tf.contrib.summary.scalar(\\\"discriminator/loss\\\", logged[\\\"disc_loss\\\"])\",\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 on_log(self):\\n monitors = self.monitors\\n if self.monitors is None:\\n monitors = self.trainer.metrics.keys()\\n\\n\\n hparams = self.hparams\\n if self.hparams is None:\\n hparams = self.trainer.hparams.keys()\\n\\n metrics = {name: format_metric(self.trainer.metrics[name])\\n for name in monitors\\n if name in self.trainer.metrics}\\n hparams = {name: format_metric(self.trainer.hparams[name])\\n for name in hparams\\n if name in self.trainer.hparams}\\n\\n\\n step_bar = self.step_bars[-1]\\n step_bar.set_description(\\\"Epoch {}\\\".format(self.trainer.epoch+1))\\n step_bar.set_postfix(**metrics, **hparams)\\n step_bar.update(self.trainer.steps_trained - self.last_step)\\n self.last_step = self.trainer.steps_trained\",\n \"def _save_model_info(self, model):\\r\\n with open_(self.output_path / \\\"model.info\\\", \\\"w+\\\") as f:\\r\\n f.write(model.info)\",\n \"def autolog(\\n every_n_iter=1,\\n log_models=True,\\n disable=False,\\n exclusive=False,\\n disable_for_unsupported_versions=False,\\n silent=False,\\n): # pylint: disable=unused-argument\\n # pylint: disable=E0611\\n import tensorflow\\n\\n global _LOG_EVERY_N_STEPS\\n _LOG_EVERY_N_STEPS = every_n_iter\\n\\n atexit.register(_flush_queue)\\n\\n if Version(tensorflow.__version__) < Version(\\\"1.12\\\"):\\n warnings.warn(\\\"Could not log to MLflow. TensorFlow versions below 1.12 are not supported.\\\")\\n return\\n\\n try:\\n from tensorflow.python.summary.writer.event_file_writer import EventFileWriter\\n from tensorflow.python.summary.writer.event_file_writer_v2 import EventFileWriterV2\\n from tensorflow.python.saved_model import tag_constants\\n from tensorflow.python.summary.writer.writer import FileWriter\\n except ImportError:\\n warnings.warn(\\\"Could not log to MLflow. TensorFlow versions below 1.12 are not supported.\\\")\\n return\\n\\n def train(original, self, *args, **kwargs):\\n active_run = mlflow.active_run()\\n global _AUTOLOG_RUN_ID\\n _AUTOLOG_RUN_ID = active_run.info.run_id\\n\\n # Checking step and max_step parameters for logging\\n if len(args) >= 3:\\n mlflow.log_param(\\\"steps\\\", args[2])\\n if len(args) >= 4:\\n mlflow.log_param(\\\"max_steps\\\", args[3])\\n if \\\"steps\\\" in kwargs:\\n mlflow.log_param(\\\"steps\\\", kwargs[\\\"steps\\\"])\\n if \\\"max_steps\\\" in kwargs:\\n mlflow.log_param(\\\"max_steps\\\", kwargs[\\\"max_steps\\\"])\\n\\n result = original(self, *args, **kwargs)\\n\\n # Flush the metrics queue after training completes\\n _flush_queue()\\n\\n # Log Tensorboard event files as artifacts\\n if os.path.exists(self.model_dir):\\n for file in os.listdir(self.model_dir):\\n if \\\"tfevents\\\" not in file:\\n continue\\n mlflow.log_artifact(\\n local_path=os.path.join(self.model_dir, file),\\n artifact_path=\\\"tensorboard_logs\\\",\\n )\\n return result\\n\\n def export_saved_model(original, self, *args, **kwargs):\\n global _AUTOLOG_RUN_ID\\n if _AUTOLOG_RUN_ID:\\n _logger.info(\\n \\\"Logging TensorFlow Estimator as MLflow Model to run with ID '%s'\\\", _AUTOLOG_RUN_ID\\n )\\n\\n serialized = original(self, *args, **kwargs)\\n\\n def log_model_without_starting_new_run():\\n \\\"\\\"\\\"\\n Performs the exact same operations as `log_model` without starting a new run\\n \\\"\\\"\\\"\\n with TempDir() as tmp:\\n artifact_path = \\\"model\\\"\\n local_path = tmp.path(\\\"model\\\")\\n mlflow_model = Model(artifact_path=artifact_path, run_id=_AUTOLOG_RUN_ID)\\n save_model_kwargs = dict(\\n tf_saved_model_dir=serialized.decode(\\\"utf-8\\\"),\\n tf_meta_graph_tags=[tag_constants.SERVING],\\n tf_signature_def_key=\\\"predict\\\",\\n )\\n save_model(path=local_path, mlflow_model=mlflow_model, **save_model_kwargs)\\n client = MlflowClient()\\n client.log_artifacts(_AUTOLOG_RUN_ID, local_path, artifact_path)\\n\\n try:\\n client._record_logged_model(_AUTOLOG_RUN_ID, mlflow_model)\\n except MlflowException:\\n # We need to swallow all mlflow exceptions to maintain backwards\\n # compatibility with older tracking servers. Only print out a warning\\n # for now.\\n _logger.warning(\\n _LOG_MODEL_METADATA_WARNING_TEMPLATE,\\n get_artifact_uri(_AUTOLOG_RUN_ID),\\n )\\n\\n log_model_without_starting_new_run()\\n\\n _AUTOLOG_RUN_ID = None\\n\\n return serialized\\n\\n @picklable_exception_safe_function\\n def _get_early_stop_callback(callbacks):\\n for callback in callbacks:\\n if isinstance(callback, tensorflow.keras.callbacks.EarlyStopping):\\n return callback\\n return None\\n\\n def _log_early_stop_callback_params(callback):\\n if callback:\\n try:\\n earlystopping_params = {\\n \\\"monitor\\\": callback.monitor,\\n \\\"min_delta\\\": callback.min_delta,\\n \\\"patience\\\": callback.patience,\\n \\\"baseline\\\": callback.baseline,\\n \\\"restore_best_weights\\\": callback.restore_best_weights,\\n }\\n mlflow.log_params(earlystopping_params)\\n except Exception: # pylint: disable=W0703\\n return\\n\\n def _get_early_stop_callback_attrs(callback):\\n try:\\n return callback.stopped_epoch, callback.restore_best_weights, callback.patience\\n except Exception: # pylint: disable=W0703\\n return None\\n\\n def _log_early_stop_callback_metrics(callback, history, metrics_logger):\\n if callback is None or not callback.model.stop_training:\\n return\\n\\n callback_attrs = _get_early_stop_callback_attrs(callback)\\n if callback_attrs is None:\\n return\\n\\n stopped_epoch, restore_best_weights, _ = callback_attrs\\n metrics_logger.record_metrics({\\\"stopped_epoch\\\": stopped_epoch})\\n\\n if not restore_best_weights or callback.best_weights is None:\\n return\\n\\n monitored_metric = history.history.get(callback.monitor)\\n if not monitored_metric:\\n return\\n\\n initial_epoch = history.epoch[0]\\n # If `monitored_metric` contains multiple best values (e.g. [0.1, 0.1, 0.2] where 0.1 is\\n # the minimum loss), the epoch corresponding to the first occurrence of the best value is\\n # the best epoch. In keras > 2.6.0, the best epoch can be obtained via the `best_epoch`\\n # attribute of an `EarlyStopping` instance: https://github.com/keras-team/keras/pull/15197\\n restored_epoch = initial_epoch + monitored_metric.index(callback.best)\\n metrics_logger.record_metrics({\\\"restored_epoch\\\": restored_epoch})\\n restored_index = history.epoch.index(restored_epoch)\\n restored_metrics = {\\n key: metrics[restored_index] for key, metrics in history.history.items()\\n }\\n # Checking that a metric history exists\\n metric_key = next(iter(history.history), None)\\n if metric_key is not None:\\n metrics_logger.record_metrics(restored_metrics, stopped_epoch + 1)\\n\\n class FitPatch(PatchFunction):\\n def __init__(self):\\n self.log_dir = None\\n\\n def _patch_implementation(\\n self, original, inst, *args, **kwargs\\n ): # pylint: disable=arguments-differ\\n unlogged_params = [\\\"self\\\", \\\"x\\\", \\\"y\\\", \\\"callbacks\\\", \\\"validation_data\\\", \\\"verbose\\\"]\\n\\n log_fn_args_as_params(original, args, kwargs, unlogged_params)\\n early_stop_callback = None\\n\\n run_id = mlflow.active_run().info.run_id\\n with batch_metrics_logger(run_id) as metrics_logger:\\n # Check if the 'callback' argument of fit() is set positionally\\n if len(args) >= 6:\\n # Convert the positional training function arguments to a list in order to\\n # mutate the contents\\n args = list(args)\\n # Make a shallow copy of the preexisting callbacks to avoid permanently\\n # modifying their contents for future training invocations. Introduce\\n # TensorBoard & tf.keras callbacks if necessary\\n callbacks = list(args[5])\\n callbacks, self.log_dir = _setup_callbacks(\\n callbacks, log_models, metrics_logger\\n )\\n # Replace the callbacks positional entry in the copied arguments and convert\\n # the arguments back to tuple form for usage in the training function\\n args[5] = callbacks\\n args = tuple(args)\\n else:\\n # Make a shallow copy of the preexisting callbacks and introduce TensorBoard\\n # & tf.keras callbacks if necessary\\n callbacks = list(kwargs.get(\\\"callbacks\\\") or [])\\n kwargs[\\\"callbacks\\\"], self.log_dir = _setup_callbacks(\\n callbacks, log_models, metrics_logger\\n )\\n\\n early_stop_callback = _get_early_stop_callback(callbacks)\\n _log_early_stop_callback_params(early_stop_callback)\\n\\n history = original(inst, *args, **kwargs)\\n\\n _log_early_stop_callback_metrics(\\n callback=early_stop_callback,\\n history=history,\\n metrics_logger=metrics_logger,\\n )\\n\\n _flush_queue()\\n mlflow.log_artifacts(\\n local_dir=self.log_dir.location,\\n artifact_path=\\\"tensorboard_logs\\\",\\n )\\n if self.log_dir.is_temp:\\n shutil.rmtree(self.log_dir.location)\\n\\n return history\\n\\n def _on_exception(self, exception):\\n if (\\n self.log_dir is not None\\n and self.log_dir.is_temp\\n and os.path.exists(self.log_dir.location)\\n ):\\n shutil.rmtree(self.log_dir.location)\\n\\n class FitGeneratorPatch(PatchFunction):\\n \\\"\\\"\\\"\\n NOTE: `fit_generator()` is deprecated in TF >= 2.1.0 and simply wraps `fit()`.\\n To avoid unintentional creation of nested MLflow runs caused by a patched\\n `fit_generator()` method calling a patched `fit()` method, we only patch\\n `fit_generator()` in TF < 2.1.0.\\n \\\"\\\"\\\"\\n\\n def __init__(self):\\n self.log_dir = None\\n\\n def _patch_implementation(\\n self, original, inst, *args, **kwargs\\n ): # pylint: disable=arguments-differ\\n unlogged_params = [\\\"self\\\", \\\"generator\\\", \\\"callbacks\\\", \\\"validation_data\\\", \\\"verbose\\\"]\\n\\n log_fn_args_as_params(original, args, kwargs, unlogged_params)\\n\\n run_id = mlflow.active_run().info.run_id\\n\\n with batch_metrics_logger(run_id) as metrics_logger:\\n # Check if the 'callback' argument of fit() is set positionally\\n if len(args) >= 5:\\n # Convert the positional training function arguments to a list in order to\\n # mutate the contents\\n args = list(args)\\n # Make a shallow copy of the preexisting callbacks to avoid permanently\\n # modifying their contents for future training invocations. Introduce\\n # TensorBoard & tf.keras callbacks if necessary\\n callbacks = list(args[4])\\n callbacks, self.log_dir = _setup_callbacks(\\n callbacks, log_models, metrics_logger\\n )\\n # Replace the callbacks positional entry in the copied arguments and convert\\n # the arguments back to tuple form for usage in the training function\\n args[4] = callbacks\\n args = tuple(args)\\n else:\\n # Make a shallow copy of the preexisting callbacks and introduce TensorBoard\\n # & tf.keras callbacks if necessary\\n callbacks = list(kwargs.get(\\\"callbacks\\\") or [])\\n kwargs[\\\"callbacks\\\"], self.log_dir = _setup_callbacks(\\n callbacks, log_models, metrics_logger\\n )\\n\\n result = original(inst, *args, **kwargs)\\n\\n _flush_queue()\\n mlflow.log_artifacts(local_dir=self.log_dir.location, artifact_path=\\\"tensorboard_logs\\\")\\n if self.log_dir.is_temp:\\n shutil.rmtree(self.log_dir.location)\\n\\n return result\\n\\n def _on_exception(self, exception):\\n if (\\n self.log_dir is not None\\n and self.log_dir.is_temp\\n and os.path.exists(self.log_dir.location)\\n ):\\n shutil.rmtree(self.log_dir.location)\\n\\n def add_event(original, self, event):\\n _log_event(event)\\n return original(self, event)\\n\\n def add_summary(original, self, *args, **kwargs):\\n result = original(self, *args, **kwargs)\\n _flush_queue()\\n return result\\n\\n managed = [\\n (tensorflow.estimator.Estimator, \\\"train\\\", train),\\n (tensorflow.keras.Model, \\\"fit\\\", FitPatch),\\n ]\\n\\n if Version(tensorflow.__version__) < Version(\\\"2.1.0\\\"):\\n # `fit_generator()` is deprecated in TF >= 2.1.0 and simply wraps `fit()`.\\n # To avoid unintentional creation of nested MLflow runs caused by a patched\\n # `fit_generator()` method calling a patched `fit()` method, we only patch\\n # `fit_generator()` in TF < 2.1.0\\n managed.append((tensorflow.keras.Model, \\\"fit_generator\\\", FitGeneratorPatch))\\n\\n non_managed = [\\n (EventFileWriter, \\\"add_event\\\", add_event),\\n (EventFileWriterV2, \\\"add_event\\\", add_event),\\n (FileWriter, \\\"add_summary\\\", add_summary),\\n (tensorflow.estimator.Estimator, \\\"export_saved_model\\\", export_saved_model),\\n (tensorflow.estimator.Estimator, \\\"export_savedmodel\\\", export_saved_model),\\n ]\\n\\n # Add compat.v1 Estimator patching for versions of tensfor that are 2.0+.\\n if Version(tensorflow.__version__) >= Version(\\\"2.0.0\\\"):\\n old_estimator_class = tensorflow.compat.v1.estimator.Estimator\\n v1_train = (old_estimator_class, \\\"train\\\", train)\\n v1_export_saved_model = (old_estimator_class, \\\"export_saved_model\\\", export_saved_model)\\n v1_export_savedmodel = (old_estimator_class, \\\"export_savedmodel\\\", export_saved_model)\\n\\n managed.append(v1_train)\\n non_managed.append(v1_export_saved_model)\\n non_managed.append(v1_export_savedmodel)\\n\\n for p in managed:\\n safe_patch(FLAVOR_NAME, *p, manage_run=True)\\n\\n for p in non_managed:\\n safe_patch(FLAVOR_NAME, *p)\",\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 log_results(best_model, model_name, max_features, train_score, test_score,\\n score_fp):\\n\\n # ensure the directorys where metrics are stored are created\\n if not os.path.exists(os.path.dirname(score_fp)):\\n os.makedirs(os.path.dirname(score_fp), exist_ok=True)\\n\\n st = datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')\\n with open(score_fp, 'a+') as f:\\n f.write(st + '\\\\n')\\n f.write('-' * 100 + '\\\\n')\\n f.write('Model Run: {}\\\\n\\\\n'.format(model_name))\\n f.write('Params: {}\\\\n\\\\n'.format(best_model.get_params())) \\n f.write('Max features: {}\\\\n\\\\n'.format(max_features))\\n f.write('Train Score: {}\\\\n\\\\n'.format(train_score))\\n f.write('Test Score: {}\\\\n\\\\n'.format(test_score))\",\n \"def train_logger(model_fn):\\n\\n @functools.wraps(model_fn)\\n def wrapper(*args, **kwargs):\\n timer_start = time.perf_counter()\\n model = model_fn(*args, **kwargs)\\n timer_end = time.perf_counter()\\n\\n time_stamp = time.localtime()\\n model_version = MODEL_VERSION\\n run_time = timer_end - timer_start\\n\\n log_entry = [time_stamp, MODEL_VERSION, run_time]\\n\\n header = \\\\\\n ','.join(TRAIN_HEADER) \\\\\\n if os.path.exists(CWD, LOG_PATH, LOG_FILE.format(LOG_TYPES['T'])) \\\\\\n else False\\n\\n create_or_update_log(LOG_TYPES['T'], log_entry, header)\\n\\n print('Logging: train logger')\\n\\n return model\\n return wrapper\",\n \"def LogProgress(model, writer, test_loader, epoch, device): \\n\\n model.eval() \\n sequential = test_loader\\n sample_batched = next(iter(sequential))\\n \\n image = torch.Tensor(sample_batched[\\\"image\\\"]).to(device)\\n depth = torch.Tensor(sample_batched[\\\"depth\\\"]).to(device)\\n \\n if epoch == 0:\\n writer.add_image(\\\"Train.1.Image\\\", vision_utils.make_grid(image.data, nrow=6, normalize=True), epoch)\\n if epoch == 0:\\n writer.add_image(\\\"Train.2.Image\\\", colorize(vision_utils.make_grid(depth.data, nrow=6, normalize=False)), epoch)\\n \\n output = DepthNorm(model(image))\\n\\n writer.add_image(\\\"Train.3.Ours\\\", colorize(vision_utils.make_grid(output.data, nrow=6, normalize=False)), epoch)\\n writer.add_image(\\\"Train.4.Diff\\\", colorize(vision_utils.make_grid(torch.abs(output-depth).data, nrow=6, normalize=False)), epoch)\\n \\n del image\\n del depth\\n del output\",\n \"def log_model(self, model_name=\\\"fixmatch_model\\\"):\\n \\n assert hasattr(self, \\\"_mlflow\\\"), \\\"need to run track_with_mlflow() first\\\"\\n from mlflow.keras import log_model\\n log_model(self._models[\\\"full\\\"], model_name)\",\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 add_summary(self):\\n merged = tf.summary.merge_all()\\n self.file_writer = tf.summary.FileWriter(self.FLAGS.model_dir, self.session.graph)\",\n \"def send_log():\\n log.info(f\\\"UUID={UUID}\\\")\\n log.info(f\\\"SPLIT={SPLIT}\\\")\\n log.info(f\\\"BATCH_SIZE={BATCH_SIZE}\\\")\\n log.info(f\\\"EPOCHS={EPOCHS}\\\")\\n log.info(f\\\"PATIENCE={PATIENCE}\\\")\\n log.info(f\\\"X_FREQ={X_FREQ}\\\")\\n log.info(f\\\"LOOK_BACK={LOOK_BACK}\\\")\\n log.info(f\\\"LOOK_AHEAD={LOOK_AHEAD}\\\")\\n log.info(f\\\"KERNEL_SIZE={KERNEL_SIZE}\\\")\\n log.info(f\\\"FILTERS={FILTERS}\\\")\\n log.info(f\\\"L1L2={L1L2}\\\")\\n log.info(f\\\"D1={D1}\\\")\\n log.info(f\\\"D2={D2}\\\")\\n log.info(f\\\"DOUT={DOUT}\\\")\\n log.info(f\\\"PLOT={PLOT}\\\")\\n log.info(f\\\"SHUFFLE={SHUFFLE}\\\")\",\n \"def _print_log(self, step, data=None):\\n \\n # Set mode to append to log file\\n mode = 'a'\\n\\n if self.logfile is None:\\n # Increment log counter for the class. Each instance of the class generates a new log.\\n self.__class__.log_no += 1\\n\\n # Create a log file for the instance\\n # Logs will be stored in ..\\\\logs\\\\SKLearn Log <n>.txt\\n self.logfile = os.path.join(os.getcwd(), 'logs', 'SKLearn Log {}.txt'.format(self.log_no))\\n \\n if step == 1:\\n # Output log header\\n output = \\\"\\\\nSKLearnForQlik Log: {0} \\\\n\\\\n\\\".format(time.ctime(time.time()))\\n # Set mode to write new log file\\n mode = 'w'\\n \\n elif step == 2:\\n # Output the parameters\\n output = \\\"Model Name: {0}\\\\n\\\\n\\\".format(self.model.name)\\n output += \\\"Execution arguments: {0}\\\\n\\\\n\\\".format(self.exec_params)\\n \\n try:\\n output += \\\"Scaler: {0}, missing: {1}, scale_hashed: {2}, scale_vectors: {3}\\\\n\\\".format(\\\\\\n self.model.scaler, self.model.missing,self.model.scale_hashed, self.model.scale_vectors)\\n output += \\\"Scaler kwargs: {0}\\\\n\\\\n\\\".format(self.model.scaler_kwargs)\\n except AttributeError:\\n output += \\\"scale_hashed: {0}, scale_vectors: {1}\\\\n\\\".format(self.model.scale_hashed, self.model.scale_vectors)\\n\\n try:\\n if self.model.dim_reduction:\\n output += \\\"Reduction: {0}\\\\nReduction kwargs: {1}\\\\n\\\\n\\\".format(self.model.reduction, self.model.dim_reduction_args)\\n except AttributeError:\\n pass\\n \\n output += \\\"Estimator: {0}\\\\nEstimator kwargs: {1}\\\\n\\\\n\\\".format(self.model.estimator, self.model.estimator_kwargs)\\n \\n elif step == 3: \\n # Output the request dataframe\\n output = \\\"REQUEST: {0} rows x cols\\\\nSample Data:\\\\n\\\\n\\\".format(self.request_df.shape)\\n output += \\\"{0}\\\\n...\\\\n{1}\\\\n\\\\n\\\".format(self.request_df.head().to_string(), self.request_df.tail().to_string())\\n \\n elif step == 4:\\n # Output the response dataframe/series\\n output = \\\"RESPONSE: {0} rows x cols\\\\nSample Data:\\\\n\\\\n\\\".format(self.response.shape)\\n output += \\\"{0}\\\\n...\\\\n{1}\\\\n\\\\n\\\".format(self.response.head().to_string(), self.response.tail().to_string())\\n \\n elif step == 5:\\n # Print the table description if the call was made from the load script\\n output = \\\"\\\\nTABLE DESCRIPTION SENT TO QLIK:\\\\n\\\\n{0} \\\\n\\\\n\\\".format(self.table)\\n \\n elif step == 6:\\n # Message when model is loaded from cache\\n output = \\\"\\\\nModel {0} loaded from cache.\\\\n\\\\n\\\".format(self.model.name)\\n \\n elif step == 7:\\n # Message when model is loaded from disk\\n output = \\\"\\\\nModel {0} loaded from disk.\\\\n\\\\n\\\".format(self.model.name)\\n \\n elif step == 8:\\n # Message when cache is updated\\n output = \\\"\\\\nCache updated. Models in cache:\\\\n{0}\\\\n\\\\n\\\".format([k for k,v in self.__class__.model_cache.items()])\\n \\n elif step == 9:\\n # Output when a parameter grid is set up\\n output = \\\"Model Name: {0}, Estimator: {1}\\\\n\\\\nGrid Search Arguments: {2}\\\\n\\\\nParameter Grid: {3}\\\\n\\\\n\\\".\\\\\\n format(self.model.name, self.model.estimator, self.model.grid_search_args, self.model.param_grid)\\n \\n elif step == 10:\\n # self.model.estimator_kwargs['architecture']\\n output = \\\"\\\\nKeras architecture added to Model {0}:\\\\n\\\\n{1}\\\\n\\\\n\\\".format(self.model.name,\\\\\\n self.model.architecture.to_string())\\n\\n elif step == 11:\\n # Output after adding lag observations to input data\\n output = \\\"Lag observations added ({0} per sample). New input shape of X is {1}.\\\\n\\\\n\\\".format(self.model.lags, data.shape)\\n output += \\\"Feature Definitions:\\\\n{0}\\\\n\\\\n\\\".format(self.model.features_df.to_string())\\n output += \\\"Sample Data:\\\\n{0}\\\\n...\\\\n{1}\\\\n\\\\n\\\".format(data.head(5).to_string(), data.tail(5).to_string())\\n \\n sys.stdout.write(output)\\n with open(self.logfile, mode, encoding='utf-8') as f:\\n f.write(output)\",\n \"def summary(self):\\n\\t\\tself.writer = tf.summary.FileWriter(\\n\\t\\t\\t\\t'./graphs/AttNCF', tf.get_default_graph())\\n\\t\\twith tf.name_scope(\\\"summaries\\\"):\\n\\t\\t\\ttf.summary.scalar('loss', self.loss)\\n\\t\\t\\tself.summary_op = tf.summary.merge_all()\",\n \"def log_train_summary(step: int,\\n *,\\n writer: metric_writers.MetricWriter,\\n train_metrics: Sequence[Dict[str, Tuple[float, int]]],\\n extra_training_logs: Optional[Sequence[Dict[str,\\n Any]]] = None,\\n metrics_normalizer_fn: Optional[\\n Callable[[Dict[str, Tuple[float, int]], str],\\n Dict[str, float]]] = None,\\n prefix: str = 'train',\\n key_separator: str = '_') -> Dict[str, float]:\\n ##### Prepare metrics:\\n # Get metrics from devices:\\n train_metrics = stack_forest(train_metrics)\\n # Compute the sum over all examples in all batches:\\n train_metrics_summary = jax.tree_map(lambda x: x.sum(), train_metrics)\\n # Normalize metrics by the total number of exampels:\\n metrics_normalizer_fn = metrics_normalizer_fn or normalize_metrics_summary\\n train_metrics_summary = metrics_normalizer_fn(train_metrics_summary, 'train')\\n\\n ##### Prepare additional training logs:\\n # If None, set to an empty dictionary.\\n extra_training_logs = extra_training_logs or {}\\n train_logs = stack_forest(extra_training_logs)\\n\\n # Metrics:\\n writer.write_scalars(\\n step, {\\n key_separator.join((prefix, key)): val\\n for key, val in train_metrics_summary.items()\\n })\\n # Additional logs:\\n writer.write_scalars(step,\\n {key: val.mean() for key, val in train_logs.items()})\\n\\n writer.flush()\\n return train_metrics_summary\",\n \"def model_summary_to_file(model, save_path):\\n with open(save_path, 'w') as fh:\\n model.summary(print_fn=lambda x: fh.write(x + \\\"\\\\n\\\"))\",\n \"def test_01_train(self):\\n today = date.today()\\n log_file = os.path.join(LOG_DIR, \\\"{}-train-{}-{}.log\\\".format(LOG_PREFIX, today.year, today.month))\\n if os.path.exists(log_file):\\n os.remove(log_file)\\n \\n ## update the log\\n country = 'india'\\n date_range = ('2017-11-29', '2019-05-24')\\n metric = {'rmse':0.5}\\n runtime = \\\"00:00:01\\\"\\n model_version = 0.1\\n model_version_note = \\\"test model\\\"\\n \\n update_train_log(country, date_range, metric, runtime,\\n model_version, model_version_note, test=True, prefix=LOG_PREFIX)\\n\\n self.assertTrue(os.path.exists(log_file))\",\n \"def create_summary_statistics(forward_accuracy, backward_accuracy, merged_accuracy):\\n summary_statistics = open(f'summary_statistics.txt', 'a')\\n summary_statistics.write(f'The forward model has an accuracy of: {forward_accuracy}\\\\n')\\n summary_statistics.write(f'The backward model has an accuracy of: {backward_accuracy}\\\\n')\\n summary_statistics.write(f'The merged model has an accuracy of: {merged_accuracy}\\\\n')\\n summary_statistics.close()\",\n \"def print_statistics(self) -> None:\\n e = self.current_epoch\\n if len(self.loss_history[\\\"test_loss\\\"]) > 0:\\n template = 'Epoch: {} Training loss: {:.4f}, Test loss: {:.4f}'\\n print(template.format(e, self.loss_history[\\\"training_loss\\\"][-1],\\n self.loss_history[\\\"test_loss\\\"][-1]))\\n else:\\n template = 'Epoch: {} Training loss: {:.4f}'\\n print(template.format(e, self.loss_history[\\\"training_loss\\\"][-1]))\",\n \"def summary(self):\\n if self.model_type == 2:\\n if self.std is None:\\n print(\\n dedent(\\n f\\\"\\\"\\\"\\\\\\n Oaxaca-Blinder Two-fold Effects\\n Unexplained Effect: {self.params[0]:.5f}\\n Explained Effect: {self.params[1]:.5f}\\n Gap: {self.params[2]:.5f}\\\"\\\"\\\"\\n )\\n )\\n else:\\n print(\\n dedent(\\n \\\"\\\"\\\"\\\\\\n Oaxaca-Blinder Two-fold Effects\\n Unexplained Effect: {:.5f}\\n Unexplained Standard Error: {:.5f}\\n Explained Effect: {:.5f}\\n Explained Standard Error: {:.5f}\\n Gap: {:.5f}\\\"\\\"\\\".format(\\n self.params[0],\\n self.std[0],\\n self.params[1],\\n self.std[1],\\n self.params[2],\\n )\\n )\\n )\\n if self.model_type == 3:\\n if self.std is None:\\n print(\\n dedent(\\n f\\\"\\\"\\\"\\\\\\n Oaxaca-Blinder Three-fold Effects\\n Endowment Effect: {self.params[0]:.5f}\\n Coefficient Effect: {self.params[1]:.5f}\\n Interaction Effect: {self.params[2]:.5f}\\n Gap: {self.params[3]:.5f}\\\"\\\"\\\"\\n )\\n )\\n else:\\n print(\\n dedent(\\n f\\\"\\\"\\\"\\\\\\n Oaxaca-Blinder Three-fold Effects\\n Endowment Effect: {self.params[0]:.5f}\\n Endowment Standard Error: {self.std[0]:.5f}\\n Coefficient Effect: {self.params[1]:.5f}\\n Coefficient Standard Error: {self.std[1]:.5f}\\n Interaction Effect: {self.params[2]:.5f}\\n Interaction Standard Error: {self.std[2]:.5f}\\n Gap: {self.params[3]:.5f}\\\"\\\"\\\"\\n )\\n )\",\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 summary(self, *args, parameters_to_show=4, **kwargs):\\n string = super(MultiAnalysisRead, self).summary(\\n show_parameters=False, show_nsamples=False\\n )\\n string += \\\"analyses: {}\\\\n\\\\n\\\".format(\\\", \\\".join(self.labels))\\n for num, label in enumerate(self.labels):\\n string += \\\"{}\\\\n\\\".format(label)\\n string += \\\"-\\\" * len(label) + \\\"\\\\n\\\"\\n string += \\\"description: {}\\\\n\\\".format(self.description[label])\\n string += \\\"nsamples: {}\\\\n\\\".format(len(self.samples[num]))\\n string += \\\"parameters: {}\\\\n\\\\n\\\".format(\\n self._parameter_summary(\\n self.parameters[num], parameters_to_show=parameters_to_show\\n )\\n )\\n return string[:-2]\",\n \"def printModelAndTime(self):\\n import time\\n self._reporter.writeOutput(\\\"Model name = \\\" + self.modelName + '\\\\n' +\\n \\\"Output directory = \\\" + self._outputDir_ + '\\\\n' +\\n \\\"Time = \\\" + time.asctime() + '\\\\n')\\n return\",\n \"def on_train_begin(self, logs=None):\\n pass\",\n \"def print_layer_trainable(model_name):\\n\\n print('trainable : layer name')\\n print('- '*30)\\n for layer in model_name.layers:\\n # if layer.trainable:\\n print(\\\"{0}:\\\\t{1}\\\".format(layer.trainable, layer.name))\\n \\n return\",\n \"def write_info(model, dataset, batch_size, learning_rate, epochs):\\n file_info = open(os.path.join(model['model_dir'], 'info.json'), 'w')\\n dic_info = {\\n 'cameras': dataset['num_cameras'],\\n 'dataset': dataset['dataset_dir'],\\n 'max_demos': dataset['max_demos'],\\n 'resume': model['resume'],\\n 'epochs': epochs,\\n 'learning_rate': learning_rate,\\n 'batch_size': batch_size\\n }\\n file_info.write(json.dumps(dic_info, cls=NumpyEncoder))\\n file_info.close()\",\n \"def show_learning_stats(track, train_loss, train_acc, valid_acc, test_acc):\\n\\n if track[\\\"valid\\\"] and track[\\\"test\\\"]:\\n print(\\\"Train loss: {:.4f} -- Train acc: {:.4f} -- Val acc: {:.4f} -- Test acc: {:.4f}\\\".format(\\n train_loss, train_acc, valid_acc, test_acc))\\n\\n if track[\\\"valid\\\"] and not track[\\\"test\\\"]:\\n print(\\\"Train loss: {:.4f} -- Train acc: {:.4f} -- Val acc: {:.4f}\\\".format(\\n train_loss, train_acc, valid_acc))\\n\\n if not track[\\\"valid\\\"] and track[\\\"test\\\"]:\\n print(\\\"Train loss: {:.4f} -- Train acc: {:.4f} -- Test acc: {:.4f}\\\".format(\\n train_loss, train_acc, test_acc))\\n\\n if not track[\\\"valid\\\"] and not track[\\\"test\\\"]:\\n print(\\\"Train loss: {:.4f} -- Train acc: {:.4f} \\\".format(\\n train_loss, train_acc))\",\n \"def stdout_logging_callback(epoch_n, batch_n, model, optimizer):\\n if not batch_n % 100:\\n logger.debug(f\\\"Epoch {epoch_n}, batch {batch_n}\\\")\",\n \"def log_step(\\n metric_dict={},\\n mode='train',\\n writer=None,\\n global_step=0,\\n elapsed_eta=None,\\n training_speed=None\\n):\\n log_msg = '[{mode}] step: {step}'\\n log_msg = log_msg.format(\\n mode=mode,\\n step=global_step,\\n )\\n for key, value in metric_dict.items():\\n log_msg += ' - {}: {}'.format(key, round(value, 4))\\n\\n # Write to tensorboard\\n if writer is not None:\\n for key, value in metric_dict.items():\\n writer.add_scalar(key, value, global_step=global_step)\\n\\n if elapsed_eta is not None:\\n log_msg += ' - elapsed: {} - eta: {}'.format(\\n datetime.timedelta(seconds=int(elapsed_eta[0])),\\n datetime.timedelta(seconds=int(elapsed_eta[1]))\\n )\\n if writer is not None:\\n writer.add_scalar('eta', elapsed_eta[1], global_step=global_step)\\n\\n if training_speed is not None:\\n log_msg += ' - step/sec: {:.4f}'.format(training_speed)\\n if writer is not None:\\n writer.add_scalar(\\n 'step/sec', training_speed, global_step=global_step)\\n\\n logger.info(log_msg)\",\n \"def get_summary(self):\\n return self.model.summary()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7465972","0.73062223","0.68315184","0.6818728","0.67563677","0.67499065","0.673236","0.6722741","0.66750515","0.6649921","0.6504973","0.64990056","0.64763284","0.64610624","0.64330405","0.64009935","0.63829356","0.6330708","0.62939197","0.62824273","0.62676394","0.6233499","0.62318116","0.6189634","0.617957","0.61774755","0.61599916","0.6115774","0.6064826","0.60516363","0.60356295","0.60329044","0.6015165","0.5992067","0.5985521","0.5952695","0.5949994","0.5949994","0.59498113","0.5947","0.5939939","0.59383816","0.59383816","0.59383816","0.59383816","0.59301627","0.5920307","0.59168065","0.59037703","0.59016293","0.5898406","0.58826697","0.5871419","0.5871419","0.5865958","0.5865037","0.58586055","0.5851803","0.5840603","0.58366513","0.5822442","0.58201534","0.5814321","0.5809398","0.5807674","0.5806668","0.57931215","0.57931215","0.57787657","0.57775223","0.5771644","0.5771357","0.5732636","0.57266724","0.5725727","0.57127154","0.5706001","0.5698657","0.56972075","0.5669949","0.56528795","0.56440693","0.5643741","0.5640987","0.5639169","0.56337357","0.5632479","0.5624435","0.5622453","0.5605884","0.5601703","0.55937994","0.5577046","0.5557792","0.554924","0.5547681","0.554533","0.5534946","0.5531204","0.55307555"],"string":"[\n \"0.7465972\",\n \"0.73062223\",\n \"0.68315184\",\n \"0.6818728\",\n \"0.67563677\",\n \"0.67499065\",\n \"0.673236\",\n \"0.6722741\",\n \"0.66750515\",\n \"0.6649921\",\n \"0.6504973\",\n \"0.64990056\",\n \"0.64763284\",\n \"0.64610624\",\n \"0.64330405\",\n \"0.64009935\",\n \"0.63829356\",\n \"0.6330708\",\n \"0.62939197\",\n \"0.62824273\",\n \"0.62676394\",\n \"0.6233499\",\n \"0.62318116\",\n \"0.6189634\",\n \"0.617957\",\n \"0.61774755\",\n \"0.61599916\",\n \"0.6115774\",\n \"0.6064826\",\n \"0.60516363\",\n \"0.60356295\",\n \"0.60329044\",\n \"0.6015165\",\n \"0.5992067\",\n \"0.5985521\",\n \"0.5952695\",\n \"0.5949994\",\n \"0.5949994\",\n \"0.59498113\",\n \"0.5947\",\n \"0.5939939\",\n \"0.59383816\",\n \"0.59383816\",\n \"0.59383816\",\n \"0.59383816\",\n \"0.59301627\",\n \"0.5920307\",\n \"0.59168065\",\n \"0.59037703\",\n \"0.59016293\",\n \"0.5898406\",\n \"0.58826697\",\n \"0.5871419\",\n \"0.5871419\",\n \"0.5865958\",\n \"0.5865037\",\n \"0.58586055\",\n \"0.5851803\",\n \"0.5840603\",\n \"0.58366513\",\n \"0.5822442\",\n \"0.58201534\",\n \"0.5814321\",\n \"0.5809398\",\n \"0.5807674\",\n \"0.5806668\",\n \"0.57931215\",\n \"0.57931215\",\n \"0.57787657\",\n \"0.57775223\",\n \"0.5771644\",\n \"0.5771357\",\n \"0.5732636\",\n \"0.57266724\",\n \"0.5725727\",\n \"0.57127154\",\n \"0.5706001\",\n \"0.5698657\",\n \"0.56972075\",\n \"0.5669949\",\n \"0.56528795\",\n \"0.56440693\",\n \"0.5643741\",\n \"0.5640987\",\n \"0.5639169\",\n \"0.56337357\",\n \"0.5632479\",\n \"0.5624435\",\n \"0.5622453\",\n \"0.5605884\",\n \"0.5601703\",\n \"0.55937994\",\n \"0.5577046\",\n \"0.5557792\",\n \"0.554924\",\n \"0.5547681\",\n \"0.554533\",\n \"0.5534946\",\n \"0.5531204\",\n \"0.55307555\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60460424"},"document_rank":{"kind":"string","value":"30"}}},{"rowIdx":4486,"cells":{"query":{"kind":"string","value":"Create a model with temperature scaling by wrapping the result of config.create_model with ModelWithTemperature, if temperature scaling config has been provided, otherwise return the result of config.create_model"},"document":{"kind":"string","value":"def create_model_with_temperature_scaling(config: ModelConfigBase) -> Any:\n # wrap the model around a temperature scaling model if required\n model = config.create_model()\n if isinstance(config, SequenceModelBase) and config.temperature_scaling_config:\n model = ModelWithTemperature(model, config.temperature_scaling_config)\n return model"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_model(self) -> None:\n self._model = create_model_with_temperature_scaling(self.config)","def do_create_model(**kwargs):\n model_params = {\n 'name': kwargs['dag_run'].conf.get('model_name'),\n 'description': 'A custom DNN regressor model',\n 'regions': [REGION]\n }\n\n ti = kwargs['ti']\n\n is_model = ti.xcom_pull(key='is_project', task_ids='check_model')\n if not is_model:\n mle = MLEngineHook()\n mle.create_model(PROJECT, model_params)","def model(self, **config_kwargs):\n measurement = self.get_measurement(**config_kwargs)\n log.debug(\n 'model being created for measurement {0:s}'.format(measurement['name'])\n )\n\n patches = config_kwargs.get('patches', [])\n\n modelspec = {\n 'channels': self.spec['channels'],\n 'parameters': measurement['config']['parameters'],\n }\n for patch in patches:\n modelspec = jsonpatch.JsonPatch(patch).apply(modelspec)\n\n return Model(modelspec, poiname=measurement['config']['poi'], **config_kwargs)","def create(model: TModel) -> ModelTransformer:\n model_backend = get_backend(model)\n if model_backend == BackendType.ONNX:\n from nncf.onnx.graph.model_transformer import ONNXModelTransformer\n\n return ONNXModelTransformer(model)\n if model_backend == BackendType.OPENVINO:\n from nncf.openvino.graph.model_transformer import OVModelTransformer\n\n return OVModelTransformer(model)\n if model_backend == BackendType.TORCH:\n from nncf.torch.model_transformer import PTModelTransformer\n\n return PTModelTransformer(model)\n raise RuntimeError(\n \"Cannot create backend-specific model transformer because {} is not supported!\".format(model_backend)\n )","def create_scaling_model(params, experiments, reflections):\n autos = [None, Auto, \"auto\", \"Auto\"]\n use_auto_model = params.model in autos\n # Determine non-auto model to use outside the loop over datasets.\n if not use_auto_model:\n model_class = None\n for entry_point in pkg_resources.iter_entry_points(\"dxtbx.scaling_model_ext\"):\n if entry_point.name == params.model:\n model_class = entry_point.load()\n break\n if not model_class:\n raise ValueError(f\"Unable to create scaling model of type {params.model}\")\n\n for expt, refl in zip(experiments, reflections):\n if not expt.scaling_model or params.overwrite_existing_models:\n # need to make a new model\n if use_auto_model:\n if not expt.scan:\n model = KBScalingModel\n else: # set model as physical unless scan < 1.0 degree\n osc_range = expt.scan.get_oscillation_range()\n abs_osc_range = abs(osc_range[1] - osc_range[0])\n if abs_osc_range < 1.0:\n model = KBScalingModel\n else:\n model = PhysicalScalingModel\n else:\n model = model_class\n expt.scaling_model = model.from_data(params, expt, refl)\n else:\n # allow for updating of an existing model.\n expt.scaling_model.update(params)\n return experiments","def calibrate_temperature(task_id, data, mnet, hnet, hhnet, device, config,\n shared, logger, writer, cal_per_model=False,\n only_correctly_classified=False,\n cal_target_entropy=-1):\n logger.info('Temperature calibration for task %d ...' % (task_id+1))\n\n # FIXME We could also follow the code from\n # https://github.com/gpleiss/temperature_scaling/blob/master/temperature_scaling.py\n # but they don't consider BNNs. Note, there code is much more efficient\n # since they compute the logits before entering the training loop (which\n # is possible when only having one model). Though, in general, we have\n # multiple models.\n\n set_train_mode(True, mnet, hnet, hhnet, None)\n\n gauss_main = False\n if isinstance(mnet, GaussianBNNWrapper):\n gauss_main = True\n\n # Whether the hypernet represents an implicit distribution (i.e., it's\n # input is a random variable), or whether it has task embeddings as input.\n det_hnet = False\n if hnet is not None:\n if hnet.num_known_conds > 0:\n assert hhnet is None\n\n det_hnet = True\n # Can currently only be the case if we train a BbB setup with option\n # `mean_only` enabled.\n if not gauss_main:\n assert hasattr(config, 'mean_only') and config.mean_only\n\n # The single parameter to be tuned by this method.\n temp_param = torch.nn.Parameter(shared.softmax_temp[task_id],\n requires_grad=True)\n assert temp_param == 1.\n\n # Which temperature transfer function to use during training. Note, this\n # can ensure that temperatures don't become negative.\n # ttf = temperature transfer function\n ttf_choice = 'softplus'\n if ttf_choice == 'linear':\n ttf = lambda x : x\n #torch.nn.init.ones_(temp_param.data)\n elif ttf_choice == 'exp':\n ttf = torch.exp\n torch.nn.init.zeros_(temp_param.data)\n else:\n ttf = F.softplus\n temp_param.data = torch.log(torch.exp(torch.ones(1)) - \\\n torch.ones(1)).to(device)\n\n allowed_outputs = pmutils.out_units_of_task(config, data, task_id,\n config.num_tasks)\n\n optimizer = tutils.get_optimizer([temp_param], config.lr,\n momentum=config.momentum, weight_decay=config.weight_decay,\n use_adam=config.use_adam, adam_beta1=config.adam_beta1,\n use_rmsprop=config.use_rmsprop, use_adadelta=config.use_adadelta,\n use_adagrad=config.use_adagrad)\n\n mnet_kwargs = pmutils.mnet_kwargs(config, task_id, mnet)\n\n num_w_samples = config.train_sample_size if config.cal_sample_size == -1 \\\n else config.cal_sample_size\n\n with torch.no_grad():\n # We don't change any network parameters, so these calls produce\n # constant outputs.\n theta_current = None\n if hhnet is not None:\n theta_current = hhnet.forward(cond_id=task_id)\n theta_current = [p.detach() for p in theta_current]\n\n if gauss_main:\n assert hhnet is None\n\n if hnet is not None:\n hnet_out = hnet.forward(cond_id=task_id)\n else:\n hnet_out = None\n w_mean, w_rho = mnet.extract_mean_and_rho(weights=hnet_out)\n w_std = putils.decode_diag_gauss(w_rho,\n logvar_enc=mnet.logvar_encoding)\n\n elif det_hnet:\n w_mean = hnet.forward(cond_id=task_id)\n\n ### We first compute the logit outputs over all samples for all models,\n ### since they don't change anymore.\n # FIXME Could lead to memory issues for large datasets and might not be\n # inefficient if ``config.cal_temp_iter`` is small, since we won't\n # iterate over the whole dataset.\n inputs = data.get_train_inputs()\n targets = data.get_train_outputs()\n\n T = data.output_to_torch_tensor(targets, device, mode='train')\n # Modify 1-hot encodings according to CL scenario.\n assert T.shape[1] == data.num_classes\n # In CL1, CL2 and CL3 (with seperate heads) we do not have to modify the\n # targets.\n if config.cl_scenario == 3 and not config.split_head_cl3:\n raise NotImplementedError('Temperature calibration not ' +\n 'implemented for CL3 without split-head.')\n\n _, labels = torch.max(T, 1) # Integer labels.\n #labels = labels.detach()\n\n num_samples = inputs.shape[0]\n\n logit_outputs = torch.empty((num_w_samples, num_samples, T.shape[1])). \\\n to(device)\n\n for j in range(num_w_samples):\n if gauss_main: # Gaussian weight posterior.\n # In case of the local-reparam trick, we anyway have a different\n # weight per sample. So, the demand of having the same model for\n # all samples in the dataset drops.\n if config.local_reparam_trick:\n # Note, the sampling will happen inside the forward method.\n weights = None\n emean = w_mean\n erho = w_rho\n else:\n weights = putils.sample_diag_gauss(w_mean, w_std,\n is_radial=config.radial_bnn)\n emean = None\n erho = None\n\n elif det_hnet:\n weights = w_mean\n\n else:\n if hnet is not None: # Implicit hypernetwork.\n z = torch.normal(torch.zeros(1, shared.noise_dim),\n config.latent_std).to(device)\n weights = hnet.forward(uncond_input=z,\n weights=theta_current)\n else: # Main network only training.\n weights = None\n\n # I use the validation batch size on purpose, since it is usually\n # bigger and we just want to quickly compute the logits.\n curr_bs = config.val_batch_size\n n_processed = 0\n\n while n_processed < num_samples:\n if n_processed + curr_bs > num_samples:\n curr_bs = num_samples - n_processed\n n_processed += curr_bs\n\n sind = n_processed - curr_bs\n eind = n_processed\n\n ### Compute negative log-likelihood (NLL).\n X = data.input_to_torch_tensor(inputs[sind:eind, :], device,\n mode='train')\n\n if gauss_main:\n Y = mnet.forward(X, weights=None, mean_only=False,\n extracted_mean=emean, extracted_rho=erho,\n sample=weights, **mnet_kwargs)\n else:\n Y = mnet.forward(X, weights=weights, **mnet_kwargs)\n\n if allowed_outputs is not None:\n Y = Y[:, allowed_outputs]\n\n logit_outputs[j, sind:eind, :] = Y\n\n # Since we computed all training logits, we might as well compute\n # the training accuracy on the predictive distributions at temperature 1\n # (note, temperature doesn't change predicted labels).\n pred_dists = F.softmax(logit_outputs, dim=2).mean(dim=0)\n assert pred_dists.ndim == 2\n _, pred_labels = torch.max(pred_dists, 1)\n train_acc = 100. * torch.sum(pred_labels == labels) / num_samples\n logger.debug('Task %d -- training accuracy: %.2f%%.' % \\\n (task_id+1, train_acc))\n\n log_pred_dists = torch.log(torch.clamp(pred_dists, min=1e-5))\n in_entropies = -torch.sum(pred_dists * log_pred_dists, dim=1)\n\n # Normalize by maximum entropy.\n max_ent = - np.log(1.0 / data.num_classes)\n in_entropies /= max_ent\n\n in_entropies_mean = in_entropies.mean()\n in_entropies_std = in_entropies.std()\n logger.debug('Task %d -- training in-dist. entropy: %f.' % \\\n (task_id+1, in_entropies_mean))\n\n if not hasattr(shared, 'train_in_ent_mean'):\n shared.train_in_ent_mean = []\n shared.train_in_ent_std = []\n shared.train_in_ent_mean.append( \\\n in_entropies_mean.detach().cpu().numpy())\n shared.train_in_ent_std.append(in_entropies_std.detach().cpu().numpy())\n\n if only_correctly_classified:\n num_correct = torch.sum(pred_labels == labels)\n\n logger.info('Task %d -- only using %d/%d correctly classified ' \\\n % (task_id+1, num_correct, num_samples) + \\\n 'samples for calibration.')\n\n logit_outputs = logit_outputs[:, pred_labels == labels, :]\n num_samples = num_correct\n assert logit_outputs.shape[1] == num_correct\n\n labels = labels[pred_labels == labels]\n assert labels.shape[0] == num_correct\n\n # Sanity check!\n pred_dists = F.softmax(logit_outputs, dim=2).mean(dim=0)\n _, pred_labels = torch.max(pred_dists, 1)\n assert torch.sum(pred_labels == labels) == num_correct\n\n logit_outputs = logit_outputs.detach()\n\n ### Calibrate temperature.\n for i in range(config.cal_temp_iter):\n optimizer.zero_grad()\n\n batch_inds = np.random.randint(0, num_samples, config.batch_size)\n\n batch_logits = logit_outputs[:, batch_inds, :]\n batch_labels = labels[batch_inds]\n assert batch_logits.ndim == 3\n\n # Note, this first option is more numerically stable when calibrating NLL.\n if cal_per_model or num_w_samples == 1:\n loss = 0\n for j in range(num_w_samples):\n if cal_target_entropy != -1:\n batch_sm = F.softmax(batch_logits[j, :, :] / \\\n ttf(temp_param), dim=1)\n # For numerical stability.\n batch_log_sm = torch.log(torch.clamp(batch_sm, min=1e-5))\n\n # Mean entropy within the batch.\n batch_entropy = -torch.sum(batch_sm * batch_log_sm,\n dim=1).mean()\n\n loss += (batch_entropy - cal_target_entropy)**2\n else: # Compute NLL loss\n # Note, softmax will be computed inside the `cross_entropy`.\n loss += F.cross_entropy( \\\n batch_logits[j, :, :] / ttf(temp_param), batch_labels,\n reduction='mean')\n loss /= num_w_samples\n\n else:\n batch_pred_dist = F.softmax(batch_logits / ttf(temp_param),\n dim=2).mean(dim=0)\n # FIXME nll_loss expects log_softmax as input. To compute the\n # predictive distribution, we have to first average softmax outputs\n # before we can apply the log, which might lead to numerical\n # instabilities.\n #batch_log_pd = batch_pred_dist\n #batch_log_pd[batch_pred_dist < 1e-5] = 1e-5\n batch_log_pd = torch.clamp(batch_pred_dist, min=1e-5)\n batch_log_pd = torch.log(batch_log_pd)\n if cal_target_entropy != -1:\n # Mean entropy within the batch.\n batch_entropy = -torch.sum(batch_pred_dist * batch_log_pd,\n dim=1).mean()\n\n loss += (batch_entropy - cal_target_entropy)**2\n else: # Compute NLL loss\n loss = F.nll_loss(batch_log_pd, batch_labels, reduction='mean')\n\n loss.backward()\n if config.clip_grad_value != -1:\n torch.nn.utils.clip_grad_value_(optimizer.param_groups[0]['params'],\n config.clip_grad_value)\n elif config.clip_grad_norm != -1:\n torch.nn.utils.clip_grad_norm_(optimizer.param_groups[0]['params'],\n config.clip_grad_norm)\n optimizer.step()\n\n if ttf_choice == 'linear':\n # NOTE In this case, nothing prevents the temperature from going\n # negative (e.g., when starting with a large learning rate).\n # Therefore, we have to actively capture this case.\n temp_param.data = torch.clamp(temp_param, min=1e-5)\n\n if i % 50 == 0:\n writer.add_scalar('cal/task_%d/loss' % task_id, loss, i)\n writer.add_scalar('cal/task_%d/temp' % task_id,\n ttf(temp_param), i)\n\n final_temp = ttf(temp_param).data\n shared.softmax_temp[task_id] = final_temp.data\n\n logger.info('Calibrated softmax temperature of task %d is: %f.' % \\\n (task_id+1, final_temp))\n\n logger.info('Temperature calibration for task %d ... Done' % (task_id+1))","def create(self, req, body):\n context = req.environ['meteos.context']\n\n if not self.is_valid_body(body, 'model'):\n raise exc.HTTPUnprocessableEntity()\n\n model = body['model']\n\n LOG.debug(\"Create model with request: %s\", model)\n\n try:\n experiment = self.engine_api.get_experiment(\n context, model['experiment_id'])\n utils.is_valid_status(experiment.__class__.__name__,\n experiment.status,\n constants.STATUS_AVAILABLE)\n template = self.engine_api.get_template(\n context, experiment.template_id)\n except exception.NotFound:\n raise exc.HTTPNotFound()\n except exception.InvalidStatus:\n raise\n\n display_name = model.get('display_name')\n display_description = model.get('display_description')\n experiment_id = model.get('experiment_id')\n source_dataset_url = model.get('source_dataset_url')\n dataset_format = model.get('dataset_format', 'csv')\n model_type = model.get('model_type')\n model_params = model.get('model_params')\n swift_tenant = model.get('swift_tenant')\n swift_username = model.get('swift_username')\n swift_password = model.get('swift_password')\n\n new_model = self.engine_api.create_model(context,\n display_name,\n display_description,\n source_dataset_url,\n dataset_format,\n model_type,\n model_params,\n template.id,\n template.job_template_id,\n experiment_id,\n experiment.cluster_id,\n swift_tenant,\n swift_username,\n swift_password)\n\n return self._view_builder.detail(req, new_model)","def create_shunt_model(self):\r\n\r\n print('\\nCreate shunt model')\r\n\r\n if not self.original_model:\r\n raise ValueError('Original model not yet initialized! Either call create_original_model or set it manually.')\r\n if not self.shunt_params:\r\n raise ValueError('No parameters found in config for shunt model! Create the field [SHUNT_MODEL]')\r\n\r\n logging.info('')\r\n logging.info('#######################################################################################################')\r\n logging.info('############################################ SHUNT MODEL ##############################################')\r\n logging.info('#######################################################################################################')\r\n logging.info('')\r\n\r\n dilation_rate_input, dilation_rate_output = find_input_output_dilation_rates(self.original_model, self.shunt_params['locations'])\r\n\r\n print('Used dilation rates: {}'.format(Architectures.get_dilation_rates(self.shunt_params['arch'], dilation_rate_input, dilation_rate_output)))\r\n logging.info('Creating shunt with dilation rates: {}'.format(Architectures.get_dilation_rates(self.shunt_params['arch'], dilation_rate_input, dilation_rate_output)))\r\n logging.info('')\r\n\r\n with self.activate_distribution_scope():\r\n if self.shunt_params['from_file']:\r\n self.shunt_model = keras.models.load_model(self.shunt_params['filepath'])\r\n print('Shunt model loaded successfully!')\r\n else:\r\n input_shape_shunt = self.original_model.get_layer(index=self.shunt_params['locations'][0]).input_shape[1:]\r\n if isinstance(input_shape_shunt, list):\r\n input_shape_shunt = input_shape_shunt[0][1:]\r\n output_shape_shunt = self.original_model.get_layer(index=self.shunt_params['locations'][1]).output_shape[1:]\r\n if isinstance(output_shape_shunt, list):\r\n output_shape_shunt = output_shape_shunt[0][1:]\r\n\r\n self.shunt_model = Architectures.createShunt(input_shape_shunt,\r\n output_shape_shunt,\r\n arch=self.shunt_params['arch'],\r\n use_se=False,\r\n dilation_rate_input=dilation_rate_input,\r\n dilation_rate_output=dilation_rate_output,\r\n expansion_factor=1.0)\r\n\r\n if self.shunt_params['pretrained']:\r\n self.shunt_model.load_weights(self.shunt_params['weightspath'])\r\n print('Shunt weights loaded successfully!')\r\n\r\n self.shunt_model.summary(print_fn=self.logger.info, line_length=150)\r\n\r\n keras.models.save_model(self.shunt_model, Path(self.folder_name_logging, \"shunt_model.h5\"))\r\n logging.info('')\r\n logging.info('Shunt model saved to {}'.format(self.folder_name_logging))\r\n\r\n # calculate flops\r\n flops_shunt = calculate_flops_model(self.shunt_model)\r\n self.flops_dict['shunt'] = flops_shunt\r\n logging.info('')\r\n logging.info('FLOPs of shunt model: {}'.format(flops_shunt))","def create_model(self, model_config):\n\n return self.conn.create_model(\n **model_config)","def create_model(config, rng, example_batch):\n example_batch = train_utils.prepare_example_batch(example_batch)\n\n key0, rng = random.split(rng, 2)\n model, variables, metric_collector = MODEL_DICT[config.model.name](\n key0, example_batch, config\n )\n\n return model, variables, metric_collector","def setup_model(msid, t0, t1, model_spec, init):\n\n model = xija.ThermalModel(msid, start=t0, stop=t1, model_spec=model_spec)\n for key, value in init.items():\n if isinstance(value, dict):\n model.comp[key].set_data(value['data'], value['times'])\n else:\n model.comp[key].set_data(value)\n\n return model","def setup_model(msid, t0, t1, model_spec, init):\n\n model = xija.ThermalModel(msid, start=t0, stop=t1, model_spec=model_spec)\n for key, value in init.items():\n if isinstance(value, dict):\n model.comp[key].set_data(value['data'], value['times'])\n else:\n model.comp[key].set_data(value)\n\n return model","def create(self) -> tf.keras.models.Model:\n raise NotImplementedError()","def create_model(model_name, random_state, epoch, device, log_path, **hparams):\n model = eval(f'{model_name}')(\n **hparams, epoch=int(epoch), random_state=random_state, device=device,\n log_path=log_path\n )\n\n return model","def get_model(model_name, model_config, to_cuda,\n uniform_initialize_bn_weight=False, forward_is_infer=False):\n model = None\n if model_name == 'Tacotron2':\n if forward_is_infer:\n class Tacotron2__forward_is_infer(Tacotron2):\n def forward(self, inputs, input_lengths):\n return self.infer(inputs, input_lengths)\n model = Tacotron2__forward_is_infer(**model_config)\n else:\n model = Tacotron2(**model_config)\n elif model_name == 'WaveGlow':\n if forward_is_infer:\n class WaveGlow__forward_is_infer(WaveGlow):\n def forward(self, spect, sigma=1.0):\n return self.infer(spect, sigma)\n model = WaveGlow__forward_is_infer(**model_config)\n else:\n model = WaveGlow(**model_config)\n else:\n raise NotImplementedError(model_name)\n\n if uniform_initialize_bn_weight:\n init_bn(model)\n\n if to_cuda:\n model = model.cuda()\n return model","def _model_fn(features, labels, mode, config):\n return _transformer_model_fn(\n features=features,\n labels=labels,\n mode=mode,\n head=head_lib._regression_head_with_mean_squared_error_loss(\n label_dimension=label_dimension,\n weight_column=weight_column,\n loss_reduction=loss_reduction),\n num_layers=num_layers,\n d_model=d_model,\n num_heads=num_heads,\n dff=dff,\n input_vocab_size=input_vocab_size,\n target_vocab_size=target_vocab_size,\n output_size=output_size,\n feature_columns=tuple(feature_columns or []),\n optimizer=optimizer,\n dropout=dropout,\n input_layer_partitioner=input_layer_partitioner,\n config=config,\n data_conf=data_conf)","def create_mean_teacher_model(self) -> None:\n self._mean_teacher_model = create_model_with_temperature_scaling(self.config)","def config_task(self) -> None:\n weights = self.hyperparams[\"weights\"]\n\n if self.hyperparams[\"model\"] == \"unet\":\n self.model = smp.Unet(\n encoder_name=self.hyperparams[\"backbone\"],\n encoder_weights=\"imagenet\" if weights is True else None,\n in_channels=self.hyperparams[\"in_channels\"],\n classes=self.hyperparams[\"num_classes\"],\n )\n elif self.hyperparams[\"model\"] == \"deeplabv3+\":\n self.model = smp.DeepLabV3Plus(\n encoder_name=self.hyperparams[\"backbone\"],\n encoder_weights=\"imagenet\" if weights is True else None,\n in_channels=self.hyperparams[\"in_channels\"],\n classes=self.hyperparams[\"num_classes\"],\n )\n elif self.hyperparams[\"model\"] == \"fcn\":\n self.model = FCN(\n in_channels=self.hyperparams[\"in_channels\"],\n classes=self.hyperparams[\"num_classes\"],\n num_filters=self.hyperparams[\"num_filters\"],\n )\n else:\n raise ValueError(\n f\"Model type '{self.hyperparams['model']}' is not valid. \"\n f\"Currently, only supports 'unet', 'deeplabv3+' and 'fcn'.\"\n )\n\n if self.hyperparams[\"loss\"] == \"ce\":\n ignore_value = -1000 if self.ignore_index is None else self.ignore_index\n\n class_weights = None\n if isinstance(self.class_weights, torch.Tensor):\n class_weights = self.class_weights.to(dtype=torch.float32)\n elif hasattr(self.class_weights, \"__array__\") or self.class_weights:\n class_weights = torch.tensor(self.class_weights, dtype=torch.float32)\n\n self.loss = nn.CrossEntropyLoss(\n ignore_index=ignore_value, weight=class_weights\n )\n elif self.hyperparams[\"loss\"] == \"jaccard\":\n self.loss = smp.losses.JaccardLoss(\n mode=\"multiclass\", classes=self.hyperparams[\"num_classes\"]\n )\n elif self.hyperparams[\"loss\"] == \"focal\":\n self.loss = smp.losses.FocalLoss(\n \"multiclass\", ignore_index=self.ignore_index, normalized=True\n )\n else:\n raise ValueError(\n f\"Loss type '{self.hyperparams['loss']}' is not valid. \"\n f\"Currently, supports 'ce', 'jaccard' or 'focal' loss.\"\n )\n\n if self.hyperparams[\"model\"] != \"fcn\":\n if weights and weights is not True:\n if isinstance(weights, WeightsEnum):\n state_dict = weights.get_state_dict(progress=True)\n elif os.path.exists(weights):\n _, state_dict = utils.extract_backbone(weights)\n else:\n state_dict = get_weight(weights).get_state_dict(progress=True)\n self.model.encoder.load_state_dict(state_dict)\n\n # Freeze backbone\n if self.hyperparams.get(\"freeze_backbone\", False) and self.hyperparams[\n \"model\"\n ] in [\"unet\", \"deeplabv3+\"]:\n for param in self.model.encoder.parameters():\n param.requires_grad = False\n\n # Freeze decoder\n if self.hyperparams.get(\"freeze_decoder\", False) and self.hyperparams[\n \"model\"\n ] in [\"unet\", \"deeplabv3+\"]:\n for param in self.model.decoder.parameters():\n param.requires_grad = False","def set_up_and_parameterise_model_for_experiment(self):\n self.experiment_unique_steps_to_model = {}\n for op_number, op in enumerate(self.experiment.unique_steps):\n new_model = self.model.new_copy()\n new_parameter_values = self.parameter_values.copy()\n\n if op.type != \"current\":\n # Voltage or power control\n # Create a new model where the current density is now a variable\n # To do so, we replace all instances of the current density in the\n # model with a current density variable, which is obtained from the\n # FunctionControl submodel\n # check which kind of external circuit model we need (differential\n # or algebraic)\n if op.type == \"voltage\":\n submodel_class = pybamm.external_circuit.VoltageFunctionControl\n elif op.type == \"power\":\n submodel_class = pybamm.external_circuit.PowerFunctionControl\n\n # Build the new submodel and update the model with it\n submodel = submodel_class(new_model.param, new_model.options)\n variables = new_model.variables\n submodel.variables = submodel.get_fundamental_variables()\n variables.update(submodel.variables)\n submodel.variables.update(submodel.get_coupled_variables(variables))\n variables.update(submodel.variables)\n submodel.set_rhs(variables)\n submodel.set_algebraic(variables)\n submodel.set_initial_conditions(variables)\n new_model.rhs.update(submodel.rhs)\n new_model.algebraic.update(submodel.algebraic)\n new_model.initial_conditions.update(submodel.initial_conditions)\n\n # Set the \"current function\" to be the variable defined in the submodel\n new_parameter_values[\"Current function [A]\"] = submodel.variables[\n \"Current [A]\"\n ]\n self.update_new_model_events(new_model, op)\n # Update parameter values\n self._original_temperature = new_parameter_values[\"Ambient temperature [K]\"]\n experiment_parameter_values = self.get_experiment_parameter_values(\n op, op_number\n )\n new_parameter_values.update(\n experiment_parameter_values, check_already_exists=False\n )\n parameterised_model = new_parameter_values.process_model(\n new_model, inplace=False\n )\n self.experiment_unique_steps_to_model[repr(op)] = parameterised_model\n\n # Set up rest model if experiment has start times\n if self.experiment.initial_start_time:\n new_model = self.model.new_copy()\n # Update parameter values\n new_parameter_values = self.parameter_values.copy()\n self._original_temperature = new_parameter_values[\"Ambient temperature [K]\"]\n new_parameter_values.update(\n {\"Current function [A]\": 0, \"Ambient temperature [K]\": \"[input]\"},\n check_already_exists=False,\n )\n parameterised_model = new_parameter_values.process_model(\n new_model, inplace=False\n )\n self.experiment_unique_steps_to_model[\n \"Rest for padding\"\n ] = parameterised_model","def evaluate_model(self, t, scaling_parameters, system_parameters):\n raise NotImplementedError","def prepare_model_(model, *data, device='cpu'):\n _auto_name('', model)\n set_default_parent(model)\n def _prep_data(d):\n if isinstance(d, (np.ndarray, torch.Tensor)):\n return torch.as_tensor(d).to(device)\n elif isinstance(d, (list, tuple)):\n if all(isinstance(x, int) for x in d):\n return torch.randn(*d, device=device)\n return [_prep_data(x) for x in d]\n elif isinstance(d, dict):\n return {k:_prep_data(v) for k, v in d.items()}\n with torch.no_grad():\n is_training = model.training\n data = [_prep_data(d) for d in data]\n model.eval()\n model.to(device)\n model(*data)\n model.train(is_training)\n return model","def build_model(self):\n model = None\n if self.model_name == 'vgg16':\n model = vgg16(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels))\n elif self.model_name == 'resnet':\n model = ResNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\n elif self.model_name == 'densenet':\n model = DenseNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\n elif self.model_name == 'mobilenet':\n model = MobileNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\n elif self.model_name == 'efficientnet':\n model = efficientnet(input_shape=(self.ex_input_size, self.ex_input_size, self.ex_channels))\n elif self.model_name == 'vit':\n model = VisionTransformer(image_size=self.ex_input_size,\n patch_size=vit_settings['patch_size'],\n num_layers=vit_settings['num_layers'],\n num_classes=num_classes,\n d_model=vit_settings['d_model'],\n num_heads=vit_settings['num_heads'],\n mlp_dim=vit_settings['mlp_dim'],\n channels=self.ex_channels,\n dropout=vit_settings['dropout']).build_VisionTransformer()\n model.load_weights(self.path_to_weights)\n model.summary()\n return model","def _random_model(self, input_size, output_size, task, config: dict) -> AbstractModel:\n return create_random_model(input_size, output_size, config, task)","def build_cut_model(self):\n model = None\n if self.model_name == 'vgg16':\n model = vgg16(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels))\n elif self.model_name == 'resnet':\n model = ResNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\n elif self.model_name == 'densenet':\n model = DenseNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\n elif self.model_name == 'mobilenet':\n model = MobileNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\n elif self.model_name == 'efficientnet':\n model = efficientnet(input_shape=(self.ex_input_size, self.ex_input_size, self.ex_channels))\n elif self.model_name == 'vit':\n model = VisionTransformer(image_size=self.ex_input_size,\n patch_size=vit_settings['patch_size'],\n num_layers=vit_settings['num_layers'],\n num_classes=num_classes,\n d_model=vit_settings['d_model'],\n num_heads=vit_settings['num_heads'],\n mlp_dim=vit_settings['mlp_dim'],\n channels=self.ex_channels,\n dropout=vit_settings['dropout']).build_VisionTransformer()\n model.load_weights(self.path_to_weights)\n model = Model(model.input, model.get_layer(self.ex_last_conv_layer_name2).output)\n model.summary()\n return model","def create_model(model_class, model_params=None, model_name='model'):\n\n model_params = {} if model_params is None else model_params\n\n model = model_class(**model_params)\n\n if special_parameters.load_model: # recover from checkpoint\n _load_model(model, model_name)\n\n # configure usage on GPU\n if use_gpu():\n model.to(first_device())\n model = torch.nn.DataParallel(model, device_ids=all_devices())\n\n # print info about devices\n print_info('Device(s)): ' + str(device_description()))\n\n return model","def _adjust_for_gpus(cls, model: DeviceAwareModule, config: ModelConfigBase,\n model_execution_mode: ModelExecutionMode) -> DeviceAwareModule:\n if config.use_gpu:\n model = model.cuda()\n logging.info(\"Adjusting the model to use mixed precision training.\")\n # If model parallel is set to True, then partition the network across all available gpus.\n if config.use_model_parallel:\n devices = config.get_cuda_devices()\n assert devices is not None # for mypy\n model.partition_model(devices=devices) # type: ignore\n else:\n logging.info(\"Making no adjustments to the model because no GPU was found.\")\n\n # Update model related config attributes (After Model Parallel Activated)\n config.adjust_after_mixed_precision_and_parallel(model)\n\n # DataParallel enables running the model with multiple gpus by splitting samples across GPUs\n # If the model is used in training mode, data parallel is activated by default.\n # Similarly, if model parallel is not activated, data parallel is used as a backup option\n use_data_parallel = (model_execution_mode == ModelExecutionMode.TRAIN) or (not config.use_model_parallel)\n if config.use_gpu and use_data_parallel:\n logging.info(\"Adjusting the model to use DataParallel\")\n # Move all layers to the default GPU before activating data parallel.\n # This needs to happen even though we put the model to the GPU at the beginning of the method,\n # but we may have spread it across multiple GPUs later.\n model = model.cuda()\n model = DataParallelModel(model, device_ids=config.get_cuda_devices())\n\n return model","def create_model():\r\n parser = argparse.ArgumentParser()\r\n parser.add_argument('--DISC_LR', type=float, default=1e-4)\r\n parser.add_argument('--GEN_LR', type=float, default=1e-3)\r\n parser.add_argument('--GEN_BETA1', type=float, default=0.9)\r\n parser.add_argument('--GEN_BETA2', type=float, default=0.999)\r\n parser.add_argument('--IMAGE_SIZE', type=int, default=None)\r\n parser.add_argument('--QUES_SIZE', type=int, default=None)\r\n parser.add_argument('--QUES_EMBED_SIZE', type=int, default=2048)\r\n parser.add_argument('--WORD_EMBED_SIZE', type=int, default=512)\r\n parser.add_argument('--VOCAB_SIZE', type=int, default=1004)\r\n args, task_args = parser.parse_known_args()\r\n override_if_not_in_args('--max_steps', '1000', task_args)\r\n override_if_not_in_args('--batch_size', '64', task_args)\r\n override_if_not_in_args('--eval_set_size', '370', task_args)\r\n override_if_not_in_args('--eval_interval_secs', '2', task_args)\r\n override_if_not_in_args('--log_interval_secs', '2', task_args)\r\n override_if_not_in_args('--min_train_eval_rate', '2', task_args)\r\n\r\n return Model(args.DISC_LR, args.GEN_LR, args.GEN_BETA1, args.GEN_BETA2,\r\n args.IMAGE_SIZE, args.QUES_EMBED_SIZE, args.WORD_EMBED_SIZE,\r\n args.QUES_SIZE, args.VOCAB_SIZE), task_args","def model_setup(params):\n n_classes = len(classes_config.training_ids)\n if general_config.model_id == constants.ssdlite:\n model = SSDLite.SSD_Head(n_classes=n_classes, k_list=anchor_config.k_list)\n elif general_config.model_id == constants.ssd:\n model = resnet_ssd.SSD300(n_classes=n_classes)\n elif general_config.model_id == constants.ssd_modified:\n model = SSDLite.SSD_Head(n_classes=n_classes, k_list=anchor_config.k_list,\n out_channels=params.out_channels, width_mult=params.width_mult)\n model.to(general_config.device)\n\n return model","def make_model(self):\n if self.model_type=='densenet_121':\n model = self.make_densenet_121(self.weights)\n\n\n return model","def create_model(configuration):\n model = find_model_using_name(configuration['model_name'])\n instance = model(configuration)\n print(\"model [{0}] was created\".format(type(instance).__name__))\n return instance","def build_model(cfg, model, gpu_id=None):\n if torch.cuda.is_available():\n assert (\n cfg.NUM_GPUS <= torch.cuda.device_count()\n ), \"Cannot use more GPU devices than available\"\n else:\n assert (\n cfg.NUM_GPUS == 0\n ), \"Cuda is not available. Please set `NUM_GPUS: 0 for running on CPUs.\"\n\n # Construct the model\n # name = cfg.MODEL.MODEL_NAME\n # model = MODEL_REGISTRY.get(name)(cfg)\n \n if cfg.NUM_GPUS:\n if gpu_id is None:\n # Determine the GPU used by the current process\n cur_device = torch.cuda.current_device()\n else:\n cur_device = gpu_id\n # Transfer the model to the current GPU device\n model = model.cuda(device=cur_device)\n # Use multi-process data parallel model in the multi-gpu setting\n if cfg.NUM_GPUS > 1:\n # Make model replica operate on the current device\n #, find_unused_parameters=True\n model = torch.nn.parallel.DistributedDataParallel(\n module=model, device_ids=[cur_device], output_device=cur_device\n )\n \n return model","def _compute_single_model(self, **kwargs):\n _, shape_parameter_settings = self._kwargs_to_settings(**kwargs)\n config = combine_dicts(self.pdf_base_config, shape_parameter_settings, deep_copy=True)\n\n config['never_save_to_cache'] = True\n return Model(config, **shape_parameter_settings)","def __call__(self,setup_options=True, instantiate_options=True, verbose=False):\n model = self.setup(setup_options)\n model(instantiate_options, verbose)\n return model","def create_model(self, **inputs):\n raise NotImplementedError('This method has to be overwritten.')","def create_model(self, fun, kwargs=None, compile=True):\n if kwargs is None:\n kwargs = {}\n\n self.model = fun(self.config.inputs, self.config.output, **kwargs)\n if compile:\n self.model.compile(\n loss=self.config.get_loss(self.modeldir),\n optimizer=\"adam\", metrics=[\"accuracy\"])","def _create_model(self):\n if torch.cuda.is_available():\n model = torch.jit.load(self.torch_jit).cuda()\n else:\n model = torch.jit.load(self.torch_jit)\n model.eval()\n return model","def backend_specific_model(model: TModel, tmp_dir: str):","def register_model(self, tags: Optional[Dict[str, str]] = None) -> Model:\n if self.run is None:\n raise ValueError(\n \"An experiment has to be run before a model can be registered\"\n )\n self.model = self.run.register_model(\n model_name=self.name,\n model_path=\"outputs/model.pkl\",\n properties=tags,\n )\n return self.model","def __init__(self,\n names,\n data,\n embedding_fns,\n encoder_fns_1,\n encoder_fns_2,\n logits_fns,\n evaluation_fns,\n # MTL\n mixing_ratios,\n L2_coefficient=None,\n is_distill=False,\n distill_coefficient_loc=None,\n distill_coefficient_scale=None,\n distill_temperature=1.0,\n # optimization\n optimizer=\"Adam\",\n learning_rate=0.001,\n gradient_clipping_norm=2.0,\n # misc\n graph=None,\n logdir=None,\n main_model_index=0,\n debug_mode=False):\n \n super(MultitaskBaseModel, self).__init__(\n logdir=logdir, graph=graph,\n saver_max_to_keep=MAX_CHECKPOINTS_TO_KEEP)\n\n num_models = len(names)\n _check_list_compatability(data, num_models)\n _check_fn_list_compatability(embedding_fns, num_models, True)\n _check_fn_list_compatability(encoder_fns_1, num_models, True)\n _check_fn_list_compatability(encoder_fns_2, num_models, True)\n _check_fn_list_compatability(logits_fns, num_models, False)\n _check_fn_list_compatability(evaluation_fns, num_models, False)\n\n # check mixing ratios and MTL\n if len(names) == 1:\n raise ValueError(\"Not supported\")\n _mr_compatible(mixing_ratios, num_models, print_out=True)\n if main_model_index != 0:\n raise ValueError(\"`main_model_index` must be set to `0`\")\n\n self._names = names\n self._data = data\n self._embedding_fns = embedding_fns\n self._encoder_fns_1 = encoder_fns_1\n self._encoder_fns_2 = encoder_fns_2\n self._logits_fns = logits_fns\n self._evaluation_fns = evaluation_fns\n\n # MTL\n self._mixing_ratios = mixing_ratios\n self._L2_coefficient = L2_coefficient\n self._is_disill = is_distill\n self._distill_temperature = distill_temperature\n self._distill_coefficient_loc = distill_coefficient_loc\n self._distill_coefficient_scale = distill_coefficient_scale\n\n self._optimizer = optimizer\n self._learning_rate = learning_rate\n self._gradient_clipping_norm = gradient_clipping_norm\n\n self._main_model_index = main_model_index\n self._debug = collections.defaultdict(list)\n self._debug_mode = debug_mode","def config_task(self) -> None:\n if self.hparams[\"model\"] == \"resnet18\":\n self.model = models.resnet18(pretrained=True)\n in_features = self.model.fc.in_features\n self.model.fc = nn.Linear( # type: ignore[attr-defined]\n in_features, out_features=1\n )\n else:\n raise ValueError(f\"Model type '{self.hparams['model']}' is not valid.\")","def build_model(cfg, gpu_id=None):\n # Construct the model\n if MODEL_REGISTRY.get(cfg.MODEL.NAME) == None:\n # attempt to find standard models\n model = BaseVideoModel(cfg)\n else:\n # if the model is explicitly defined,\n # it is directly constructed from the model pool\n model = MODEL_REGISTRY.get(cfg.MODEL.NAME)(cfg)\n\n if torch.cuda.is_available():\n assert (\n cfg.NUM_GPUS <= torch.cuda.device_count()\n ), \"Cannot use more GPU devices than available\"\n else:\n assert (\n cfg.NUM_GPUS == 0\n ), \"Cuda is not available. Please set `NUM_GPUS: 0 for running on CPUs.\"\n\n if cfg.NUM_GPUS:\n if gpu_id is None:\n # Determine the GPU used by the current process\n cur_device = torch.cuda.current_device()\n else:\n cur_device = gpu_id\n model = model.cuda(device=cur_device)\n \n model_ema = None\n if cfg.MODEL.EMA.ENABLE:\n model_ema = ModelEmaV2(model, decay=cfg.MODEL.EMA.DECAY)\n\n try:\n # convert batchnorm to be synchronized across \n # different GPUs if needed\n sync_bn = cfg.BN.SYNC_BN\n if sync_bn == True and cfg.NUM_GPUS * cfg.NUM_SHARDS > 1:\n model = nn.SyncBatchNorm.convert_sync_batchnorm(model)\n except:\n sync_bn = None\n\n # Use multi-process data parallel model in the multi-gpu setting\n if cfg.NUM_GPUS*cfg.NUM_SHARDS > 1:\n # Make model replica operate on the current device\n if cfg.PAI:\n # Support distributed training on the cluster\n model = torch.nn.parallel.DistributedDataParallel(\n module=model\n )\n else:\n model = torch.nn.parallel.DistributedDataParallel(\n module=model, device_ids=[cur_device], output_device=cur_device\n )\n\n return model, model_ema","def create_model(ModelName=None, PrimaryContainer=None, Containers=None, ExecutionRoleArn=None, Tags=None, VpcConfig=None, EnableNetworkIsolation=None):\n pass","def create_and_copy_model(model, create_model_func, **kwargs):\n new_model = create_model_func(**kwargs)\n\n update_model_weights( # copy trainable weights\n new_model, model.trainable_weights,\n weights_structure=get_model_weights_structure(new_model, trainable=True),\n trainable=True, force_update=True)\n\n update_model_weights( # copy non-trainable weights\n new_model, model.non_trainable_weights,\n weights_structure=get_model_weights_structure(new_model, trainable=False),\n trainable=False, force_update=True)\n\n # make sure that model is \"built\" and new variables are not created\n build_model(new_model, model.input_shape)\n\n return new_model","def from_pretrained(model_name: str, aliases: Dict = None, device: str = None):\n if device == None:\n device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n\n model = None\n\n models = AutoModel.list_models(return_dict=True)\n model_config = models.get(model_name)\n\n # Try to find by alias\n if model_config == None and aliases:\n name_from_alias = aliases.get(model_name)\n\n if name_from_alias:\n model_config = models.get(name_from_alias)\n if model_config:\n model_name = name_from_alias\n\n # Try to load from local saved model\n if model_config == None:\n try:\n model = load(model_name)\n model.to(device)\n except ValueError:\n raise ValueError(f\"Model '{model_name}' not found\")\n \n if model == None:\n model_class = model_config[\"class\"]\n init_kwargs = model_config[\"init_kwargs\"]\n\n model = model_config[\"class\"](**init_kwargs,\n description=model_config[\"description\"],\n tasks=model_config[\"tasks\"],\n name=model_name,\n details=model_config.get(\"details\"),\n device=device)\n\n return model","def prepare(cls, model, device, **kwargs):\n super(SingaBackend, cls).prepare(model, device, **kwargs)\n # when parsing graph, we use the shape of input gived by onnx to init a random value\n # HOWEVER, the random value may not be correct for some inputs, such as gather which needs indices\n # so if have operators, the user must give inputs\n init_inputs = kwargs.get(\"init_inputs\", None)\n # whether initializers are moved into inputs, due to https://github.com/onnx/onnx/issues/2417\n # sometimes, input contains all initializer's info, sometimes, may not\n cls.keep_initializers_as_inputs = kwargs.get(\n 'keep_initializers_as_inputs', True)\n # optimize and infer the shape of the model\n try:\n model = onnx.utils.polish_model(model)\n except IndexError as err:\n # due to https://github.com/onnx/onnx/issues/2417\n model = onnx.shape_inference.infer_shapes(model)\n\n # check the opset version and ir version\n opset_version = None\n for imp in model.opset_import:\n if not imp.HasField(\"domain\") or imp.domain == \"\":\n opset_version = imp.version\n if imp.version > cls._known_opset_version:\n warnings.warn(\n \"This version of singa targets ONNX operator set version {}, but the model we are trying to import uses version {}. We will try to import it anyway, but if the model uses operators which had BC-breaking changes in the intervening versions, import will fail.\"\n .format(cls._known_opset_version, imp.version))\n else:\n warnings.warn(\"Unrecognized operator set {}\".format(imp.domain))\n if opset_version is None:\n if model.ir_version >= 0x00000003:\n raise RuntimeError(\n \"Model with IR version >= 3 did not specify ONNX operator set version (singa requires it)\"\n )\n else:\n opset_version = 1\n weights, singa_ops = cls._onnx_model_to_singa_net(\n model, init_inputs, device, opset_version)\n return SingaRep(model, weights, singa_ops,\n cls.keep_initializers_as_inputs)","def tff_model_fn():\n keras_model = load_model(FLAGS.batch_size)\n loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n return simple_fedavg_tf.KerasModelWrapper(keras_model,\n test_data.element_spec, loss)","def from_config(cls, *args, **kwargs):\n _config = args\n\n if isinstance(args, tuple): # multiple non-keyword arguments were provided\n if len(args) > 0:\n _config = args[0]\n\n else:\n _config = kwargs['config_path']\n kwargs.pop('config_path')\n\n local = False\n if 'make_new_path' in kwargs:\n local = True\n elif isinstance(_config, str) and os.path.isfile(_config):\n local = True\n elif isinstance(_config, dict) and \"category\" in _config:\n local = True\n\n if local:\n config = None\n config_path = None\n\n # we need to build ai4water's Model class\n if isinstance(_config, dict):\n config = _config\n else:\n config_path = _config\n return BaseModel._get_config_and_path(\n cls,\n config=config,\n config_path=config_path,\n **kwargs\n )\n\n # tf1.15 has from_config so call it\n return super().from_config(*args, **kwargs)","def initialize_multitask_model(\n *,\n model_def: nn.Module,\n input_spec: Dict[Tuple[Tuple[str, str], ...],\n Sequence[Union[Tuple[Tuple[int, ...], jnp.dtype],\n Tuple[int, ...]]]],\n config: ml_collections.ConfigDict,\n rngs: Union[jnp.ndarray, Mapping[str, jnp.ndarray]],\n) -> Tuple[PyTree, PyTree, int, Optional[Dict[str, float]]]:\n\n def init_fn(model_def):\n for kwargs, in_spec in input_spec.items():\n\n if config.get('batch_sizes') is not None:\n batch_size = config.batch_sizes.get(dict(kwargs)['dataset'])\n else:\n batch_size = config.batch_size\n\n batch_size = (batch_size // jax.device_count()) if batch_size else None\n\n input_shapetype = [\n debug_utils.input_spec_to_jax_shape_dtype_struct(\n spec, batch_size=batch_size) for spec in in_spec\n ]\n dummy_input = []\n for in_st in input_shapetype:\n dummy_input.append(jnp.zeros(in_st.shape, in_st.dtype))\n model_def(\n *dummy_input, train=False, debug=False, **dict(kwargs))\n\n # We want all parameters to be created in host RAM, not on any device, they'll\n # be sent there later as needed, otherwise we already encountered two\n # situations where we allocate them twice.\n @functools.partial(jax.jit, backend='cpu')\n def _initialize_model(rngs):\n \"\"\"Initialization function to be jitted.\"\"\"\n init_model_state, init_params = nn.init(\n fn=init_fn, module=model_def)(rngs).pop('params')\n # Set bias in the head to low value, such that loss is small initially.\n if (config.get('init_head_bias', None) is not None and\n 'output_projection' in init_params):\n init_params = flax.core.unfreeze(init_params)\n init_params['output_projection'] = optimizers.tree_map_with_names(\n lambda p: jnp.full_like(p, config.init_head_bias),\n init_params['output_projection'],\n match_name_fn=lambda name: 'bias' in name)\n init_params = flax.core.freeze(init_params)\n return init_params, init_model_state\n\n if not isinstance(rngs, dict):\n rngs = {'params': rngs}\n init_params, init_model_state = _initialize_model(rngs)\n # Pop out params rng:\n rngs.pop('params')\n\n # Count number of trainable parameters:\n num_trainable_params = debug_utils.log_param_shapes(init_params)\n\n # Count gflops:\n count_flops = config.get('count_flops',\n ml_collections.ConfigDict({'count_flops': True}))\n if count_flops:\n variables = {'params': init_params, **init_model_state}\n gflops_dict = {}\n gflops_all = 0\n for kwargs, in_spec in input_spec.items():\n flops = debug_utils.compute_flops(\n flax_model_apply_fn=functools.partial(\n model_def.apply,\n variables,\n train=False,\n debug=False,\n rngs=rngs,\n **dict(kwargs)),\n input_spec=count_flops.get('input_spec', in_spec),\n fuse_multiply_add=count_flops.get('fuse_multiply_add', True))\n gflops = flops / (10**9)\n gflops_key = 'gflops/' + '/'.join(f'{x}={y}' for x, y in kwargs)\n gflops_dict[gflops_key] = gflops\n gflops_all += gflops\n gflops_dict['gflops'] = gflops_all\n else:\n gflops_dict = None\n\n return init_params, init_model_state, num_trainable_params, gflops_dict","def construct_model(self, output_model_path):\n\n input_tensor = helper.make_tensor_value_info(\"input\", TensorProto.FLOAT, [1, 1, 7, 7])\n output_tensor = helper.make_tensor_value_info(\"output\", TensorProto.FLOAT, [1, 1, 8, 8])\n ini_w = helper.make_tensor(\"weight\", TensorProto.FLOAT, [1, 1, 2, 2], [1.0, 1.0, 1.0, 1.0])\n ini_b = helper.make_tensor(\"bias\", TensorProto.FLOAT, [1], [0.17])\n conv_tranpose_node = onnx.helper.make_node(\n \"ConvTranspose\",\n [\"input\", \"weight\", \"bias\"],\n [\"output\"],\n kernel_shape=[2, 2],\n output_padding=[0, 0],\n pads=[0, 0, 0, 0],\n strides=[1, 1],\n dilations=[1, 1],\n group=1,\n )\n graph = helper.make_graph(\n [conv_tranpose_node],\n \"conv_transpose_test\",\n [input_tensor],\n [output_tensor],\n initializer=[ini_w, ini_b],\n )\n model = helper.make_model(graph, opset_imports=[helper.make_opsetid(\"\", 13)])\n model.ir_version = 7 # use stable onnx ir version\n\n onnx.save(model, output_model_path)","def build_model(model_name: Text,\n model_config: archs.MobileNetConfig,\n dataset_config: Optional[dataset_factory.DatasetConfig] = None,\n ) -> tf.keras.models.Model:\n\n model_build_function = _get_model_builder().get(model_name)\n if model_build_function:\n if dataset_config:\n image_size = dataset_config.image_size\n channels = dataset_config.num_channels\n model_config.input_shape = (image_size, image_size, channels)\n model_config.num_classes = dataset_config.num_classes\n return model_build_function(config=model_config)\n else:\n raise ValueError('The model {} is not supported.'.format(model_name))","def create_model(self):\n model = solph.Model(self.es)\n return model","def __init__(self, data_set, model, config):\n\n self.config = config\n self.data_set = data_set\n # Normalize or standardize the features, to have them ready to use as model input\n self.data_set.shift_and_scale(self.config[\"shift\"], self.config[\"scaling\"])\n self.model = model\n self.model.eval()\n self.device = torch.device(\"cpu\") if not self.config[\"use_gpu\"] \\\n else torch.device(\"cuda:\" + str(self.config[\"gpu_no\"]))","def config_from_pytorch_model(\n model,\n granularity='model',\n backend=None,\n default_precision='ap_fixed<16,6>',\n default_reuse_factor=1,\n inputs_channel_last=False,\n transpose_outputs=True,\n):\n\n config = {}\n\n model_config = {}\n model_config['Precision'] = default_precision\n model_config['ReuseFactor'] = default_reuse_factor\n model_config['InputsChannelLast'] = inputs_channel_last\n model_config['TransposeOutputs'] = transpose_outputs\n model_config['Strategy'] = 'Latency'\n\n config['Model'] = model_config\n\n return config","def train_model(self) -> Model:\n run = self.submit_experiment_run(wait_for_completion=self.wait_for_completion)\n model = run.register_model(\n model_name=self.model_name, model_path=self.model_path\n )\n return model","def model_fn_builder(config: electra_files.configure_finetuning.FinetuningConfig, tasks,\n num_train_steps, pretraining_config=None):\n\n def model_fn(features, labels, mode, params):\n \"\"\"The `model_fn` for TPUEstimator.\"\"\"\n utils.log(\"Building model...\")\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\n model = FinetuningModel(\n config, tasks, is_training, features, num_train_steps)\n\n if pretraining_config is not None:\n # init_checkpoint = tf.train.latest_checkpoint(pretraining_config.model_dir)\n init_checkpoint = pretraining_config['checkpoint']\n utils.log(\"Using checkpoint\", init_checkpoint)\n tvars = tf.trainable_variables()\n scaffold_fn = None\n if init_checkpoint:\n assignment_map, _ = modeling.get_assignment_map_from_checkpoint(\n tvars, init_checkpoint)\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n\n # Build model for training or prediction\n if mode == tf.estimator.ModeKeys.TRAIN:\n train_op = optimization.create_optimizer(\n model.loss, config.learning_rate, num_train_steps,\n weight_decay_rate=config.weight_decay_rate,\n use_tpu=config.use_tpu,\n warmup_proportion=config.warmup_proportion,\n layerwise_lr_decay_power=config.layerwise_lr_decay,\n n_transformer_layers=model.bert_config.num_hidden_layers\n )\n output_spec = tf.estimator.tpu.TPUEstimatorSpec(\n mode=mode,\n loss=model.loss,\n train_op=train_op,\n scaffold_fn=scaffold_fn,\n training_hooks=[training_utils.ETAHook(\n {} if config.use_tpu else dict(loss=model.loss),\n num_train_steps, config.iterations_per_loop, config.use_tpu, 10)])\n else:\n assert mode == tf.estimator.ModeKeys.PREDICT\n output_spec = tf.estimator.tpu.TPUEstimatorSpec(\n mode=mode,\n predictions=utils.flatten_dict(model.outputs),\n scaffold_fn=scaffold_fn)\n\n utils.log(\"Building complete\")\n return output_spec\n\n return model_fn","def get_model_adapter(config):\n if config['task'] == 'joint':\n return JointModelAdapter()\n elif config['task'] == 'keypoints':\n return KeypointsModelAdapter()\n elif config['task'] == 'headsegmentation':\n return HeadSegmentationModelAdapter()\n elif config['task'] == 'detect':\n return DetectionModelAdapter(config['model'])\n return ClassificationModelAdapter()","def eval_model(config):\n print 'Model directory: %s' % config.model_output\n print 'Running model: %s' % config.model_type\n if config.model_type == 'fully_connected_mlp':\n from models.fully_connected_mlp import model_struct\n elif config.model_type == 'fully_connected_mlp_2l':\n from models.fully_connected_mlp_2l import model_struct\n elif config.model_type == 'fully_connected_conv':\n from models.fully_connected_conv import model_struct\n elif config.model_type == 'vgg_feature_model':\n from models.vgg_feature_model import model_struct\n else:\n raise Exception\n\n # Prepare model training\n dt_stamp = re.split(\n '\\.', str(datetime.now()))[0].\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\n dt_dataset = config.model_type + '_' + dt_stamp + '/'\n config.train_checkpoint = os.path.join(\n config.model_output, dt_dataset) # timestamp this run\n config.summary_dir = os.path.join(\n config.train_summaries, config.model_output, dt_dataset)\n dir_list = [config.train_checkpoint, config.summary_dir]\n [make_dir(d) for d in dir_list]\n\n # Prepare model inputs\n train_data = os.path.join(config.tfrecord_dir, 'train.tfrecords')\n validation_data = os.path.join(config.tfrecord_dir, 'val.tfrecords')\n feat_mean = 0 # np.mean(np.load(config.mean_file)['feat_list'])\n\n # Prepare data on CPU\n with tf.device('/cpu:0'):\n train_images, train_labels = inputs(\n tfrecord_file=train_data,\n batch_size=config.train_batch,\n num_feats=config.n_features,\n sample=config.sample['train'],\n max_pixels_per_image=config.max_pixels_per_image,\n im_size=config.resize,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n num_epochs=config.epochs,\n feat_mean_value=feat_mean)\n val_images, val_labels = inputs(\n tfrecord_file=validation_data,\n batch_size=1,\n num_feats=config.n_features,\n sample=config.sample['val'],\n max_pixels_per_image=config.max_pixels_per_image,\n im_size=config.resize,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n num_epochs=config.epochs,\n feat_mean_value=feat_mean)\n tf.summary.image('validation images', tf.cast(val_labels, tf.float32))\n\n # Prepare model on GPU\n with tf.device('/gpu:0'):\n with tf.variable_scope('cnn') as scope:\n\n model = model_struct()\n train_mode = tf.get_variable(name='training', initializer=True)\n model.build(\n features=train_images,\n output_categories=len(config.labels.keys()),\n train_mode=train_mode, batchnorm=config.batch_norm)\n\n # Prepare the cost function\n cost = softmax_cost(\n model.res_logits, train_labels, ratio=config.ratio,\n label_reshape=[\n config.batch_size * config.max_pixels_per_image])\n train_op = tf.train.AdamOptimizer(config.lr).minimize(cost)\n\n tf.summary.scalar(\"cost\", cost)\n\n train_score = correlation(\n model.prob, train_labels) # training accuracy\n tf.summary.scalar(\"training correlation\", train_score)\n\n # Setup validation op\n if validation_data is not False:\n scope.reuse_variables()\n # Validation graph is the same as training except no batchnorm\n val_model = model_struct()\n val_model.build(\n features=val_images,\n output_categories=len(config.labels.keys()))\n\n # Calculate validation accuracy\n val_pred = tf.cast(\n tf.reshape(\n tf.argmax(\n val_model.prob, axis=1),\n [1, config.resize[0], config.resize[1], 1]),\n tf.float32)\n tf.summary.image('validation prediction', val_pred)\n val_score = correlation(\n val_model.prob, tf.reshape(\n val_labels, [np.prod(config.resize), 1]))\n tf.summary.scalar(\"validation correlation\", val_score)\n\n # Set up summaries and saver\n saver = tf.train.Saver(\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\n summary_op = tf.summary.merge_all()\n\n # Initialize the graph\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\n\n # Need to initialize both of these if supplying num_epochs to inputs\n sess.run(tf.group(tf.global_variables_initializer(),\n tf.local_variables_initializer()))\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\n\n # Set up exemplar threading\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n\n # Start training loop\n np.save(config.train_checkpoint, config)\n step, val_max, losses = 0, 0, []\n train_acc = 0\n try:\n while not coord.should_stop():\n start_time = time.time()\n _, loss_value, train_acc = sess.run([train_op, cost, train_score])\n losses.append(loss_value)\n duration = time.time() - start_time\n assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\n\n if step % 100 == 0 and step % 10 == 0:\n if validation_data is not False:\n _, val_acc, val_frame = sess.run(\n [train_op, val_score, val_pred])\n\n np.save(\n os.path.join(\n config.model_output, '%s_val_image' % step),\n val_frame)\n else:\n val_acc = -1 # Store every checkpoint\n\n # Summaries\n summary_str = sess.run(summary_op)\n summary_writer.add_summary(summary_str, step)\n\n # Training status and validation accuracy\n format_str = (\n '%s: step %d, loss = %.2f (%.1f examples/sec; '\n '%.3f sec/batch) | Training r = %s | '\n 'Validation r = %s | logdir = %s')\n print (format_str % (\n datetime.now(), step, loss_value,\n config.train_batch / duration, float(duration),\n train_acc, val_acc, config.summary_dir))\n\n # Save the model checkpoint if it's the best yet\n if val_acc > val_max:\n saver.save(\n sess, os.path.join(\n config.train_checkpoint,\n 'model_' + str(step) + '.ckpt'), global_step=step)\n\n # Store the new max validation accuracy\n val_max = val_acc\n\n else:\n # Training status\n format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; '\n '%.3f sec/batch) | Training F = %s')\n print (format_str % (datetime.now(), step, loss_value,\n config.train_batch / duration,\n float(duration), train_acc))\n # End iteration\n step += 1\n\n except tf.errors.OutOfRangeError:\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\n finally:\n coord.request_stop()\n\n dt_stamp = get_dt() # date-time stamp\n np.save(\n os.path.join(\n config.tfrecord_dir, '%straining_loss' % dt_stamp), losses)\n coord.join(threads)\n sess.close()","def make_model(cls, model_id: str):\n try:\n make_model = getattr(importlib.import_module(\"kgcnn.literature.%s\" % model_id), \"make_model\")\n\n except ModuleNotFoundError:\n raise NotImplementedError(\"ERROR:kgcnn: Unknown model identifier %s\" % model_id)\n\n return make_model","def createNewModel(self, modelName):\n try:\n storage = FileSystemStorage(join(settings.MEDIA_ROOT, 'models'))\n\n folderSufix = 1\n new_model_name = modelName\n while storage.exists(join(storage.base_location, new_model_name)):\n folderSufix += 1\n new_model_name = f'{modelName}_{folderSufix}'\n\n folder_path = join(storage.base_location, new_model_name)\n model_file = join(folder_path, f'{new_model_name}.ppl')\n\n if not storage.exists(folder_path):\n os.mkdir(folder_path)\n\n calcEngine = CalcEngine.factory(self.client_session)\n if calcEngine.createNewModel(model_file, new_model_name):\n self.closeModel()\n return self.openModel(join(storage.base_location, new_model_name, f'{new_model_name}.ppl'))\n except Exception as ex:\n raise ex","def build_variational_keras_model(\n input_shape=[1],\n layer_units=[200, 100, 1],\n layer_activations=[\"relu\", \"relu\", \"linear\"],\n initial_unconstrained_scale=None,\n transform_unconstrained_scale_factor=0.05,\n normalization_layer=False,\n prior_scale_identity_multiplier=1,\n kl_weight=None,\n noise_scale_prior=None,\n n_train=None,\n mean_init_noise_scale=0.0,\n names=None,\n evaluate_ignore_prior_loss=True,\n):\n if names is None:\n names = [None] * len(layer_units)\n\n # model = tf.keras.Sequential()\n input = tf.keras.Input(shape=input_shape)\n if normalization_layer:\n x = NormalizationFix(input_shape=input_shape, name=\"normalization\")(input)\n\n prior = prior_fn_factory(prior_scale_identity_multiplier)\n posterior_mean_field = posterior_mean_field_generator(mean_init_noise_scale)\n for i, units, activation, name in zip(\n range(len(layer_units)), layer_units, layer_activations, names\n ):\n layer = tfp.layers.DenseVariational(\n units,\n activation=activation,\n name=name,\n make_posterior_fn=posterior_mean_field,\n make_prior_fn=prior,\n kl_weight=kl_weight,\n use_bias=True,\n )\n if i == 0 and not normalization_layer:\n x = layer(input)\n else:\n x = layer(x)\n if initial_unconstrained_scale is not None:\n x = AddSigmaLayer(initial_unconstrained_scale, name=\"sigma_layer\")(x)\n x = tfp.layers.DistributionLambda(\n lambda t: tfd.Normal(\n loc=t[..., :1],\n scale=transform_unconstrained_scale(\n t[..., 1:], transform_unconstrained_scale_factor\n ),\n )\n )(x)\n if evaluate_ignore_prior_loss:\n model = ValidationModel(inputs=input, outputs=x)\n else:\n model = tf.keras.Model(inputs=input, outputs=x)\n if initial_unconstrained_scale is not None:\n if noise_scale_prior is not None:\n model.add_loss(\n lambda: -tf.reduce_sum(\n noise_scale_prior.log_prob(\n transform_unconstrained_scale(\n model.get_layer(\"sigma_layer\").sigma,\n transform_unconstrained_scale_factor,\n )\n )\n )\n / n_train\n )\n return model","def create_model(self, setting: SettingType) -> BaselineModel[SettingType]:\n # Create the model, passing the setting, hparams and config.\n return MyCustomModel(setting=setting, hparams=self.hparams, config=self.config)","def create_model(feats2d, shapes, model_settings, model_architecture,\n is_training, runtime_settings=None):\n if model_architecture == 'single_fc':\n return create_single_fc_model(feats2d, shapes, model_settings, is_training)\n elif model_architecture == 'simple_conv2D':\n return create_simple_conv2D_model(feats2d, shapes, model_settings, is_training)\n elif model_architecture == 'simple_conv1D':\n return create_simple_conv1D_model(feats2d, shapes, model_settings, is_training)\n elif model_architecture == 'lstm':\n return create_bidirectionnal_dynamic_rnn_model(feats2d, shapes, model_settings, is_training)\n elif model_architecture == 'cnn_lstm':\n return create_CNN_LSTM_model(feats2d, shapes, model_settings, is_training)\n elif model_architecture == 'dcnn_lstm':\n return create_DCNN_LSTM_model(feats2d, shapes, model_settings, is_training)\n else:\n raise Exception('model_architecture argument \"' + model_architecture +\n '\" not recognized, should be one of \"single_fc\", \"simple_conv2D\",' +\n ' \"simple_conv1D\", or \"lstm\"')","def build_model(\n model_purpose: str,\n name: str,\n init_w: str,\n input_shape: np.ndarray,\n classes: int,\n dropout_rate: np.float32,\n) -> keras.Model:\n\n if model_purpose.startswith(\"segmentation\"):\n seg_builder = sm.Seg_model_builder(name, input_shape, classes, dropout_rate)\n model = seg_builder.get_model()\n\n elif model_purpose == \"inversion\":\n reg_builder = rm.Reg_model_builder(name, input_shape, classes, init_w)\n model = reg_builder.get_model()\n\n elif model_purpose == \"pixel_concentration_retrieval\":\n model = pwrm.Unet_2(input_shape, classes)\n\n return model","def _create_model(self):\n ref = 0 if self.m_cfg['configs']['recursive'] else -1\n out_t, l_t, models = [], [], []\n in_t = [tf.keras.Input(batch_size=self.m_cfg['configs']['batch'],\n shape=self.m_cfg['configs']['patch'])]\n for level in np.arange(self.levels):\n if not self.m_cfg['configs']['recursive'] or not level:\n lat, res, layers = self._set_level_ops(in_t[-1], level)\n opt = self._inst_optimizer()\n self.opt += [opt]\n curr_layers = sum(layers, [])\n vars = sum(list(map(lambda l: l.variables, curr_layers)), [])\n self.vars.append(vars)\n elif self.m_cfg['configs']['recursive']:\n lat, res, layers = self._set_level_ops(in_t[-1], level, layers)\n\n out_t += [res]\n l_t += [lat]\n in_t += [tf.keras.layers.Subtract()([in_t[ref], out_t[-1]])]\n\n inputs, outputs = in_t[0], [in_t[:-1], l_t, out_t]\n self.model = tf.keras.Model(inputs=inputs, outputs=outputs)\n self.loss = Losses(self.m_cfg['configs']['loss']).value","def _InstantiateTaskModel(\n self, task_params\n ) -> Union[base_model.SingleTaskModel, base_model.MultiTaskModel]:\n if issubclass(task_params.cls, base_model.MultiTaskSubModel):\n return task_params.Instantiate(\n shared_model=self._shared_model, executor_ema=self._executor_ema)\n return task_params.Instantiate(executor_ema=self._executor_ema)","def buildModel(model_name):\n if model_name == \"resnet50\":\n model = kapp.resnet50.ResNet50(weights=\"imagenet\", include_top=False)\n return model, kapp.resnet50.preprocess_input\n elif model_name == \"vgg16\":\n model = kapp.vgg16.VGG16(weights=\"imagenet\", include_top=False)\n return model, kapp.vgg16.preprocess_input\n elif model_name == 'xception':\n model = kapp.xception.Xception(weights=\"imagenet\", include_top=False)\n return model, kapp.xception.preprocess_input\n elif model_name == 'vgg19':\n model = kapp.vgg19.VGG19(weights=\"imagenet\", include_top=False)\n return model, kapp.vgg19.preprocess_input\n elif model_name == 'inceptionv3':\n model = kapp.inception_v3.InceptionV3(weights=\"imagenet\", include_top=False)\n return model, kapp.inception_v3.preprocess_input\n elif model_name == 'mobilenet':\n model = kapp.mobilenet.MobileNet(weights=\"imagenet\", include_top=False)\n return model, kapp.mobilenet.preprocess_input\n else:\n raise Exception(\"Unsupported model error\")","def create(self, task_model):\n raise NotImplementedError()","def setup_model(self,\n model_weights_path: Optional[str] = None,\n model_def_path: Optional[str] = None) -> None:\n if self.model is not None:\n self.model.to(self.device)\n return\n\n self._onnx_mode = (model_weights_path is not None\n and model_weights_path.lower().endswith('.onnx'))\n if self._onnx_mode:\n model = self.load_onnx_model(model_weights_path)\n else:\n model = self.build_model(model_def_path)\n\n if self.cfg.model.external_def is not None:\n # this model will have 1 extra output classes that we will ignore\n self.model = TorchVisionODAdapter(model, ignored_output_inds=[0])\n else:\n # this model will have 2 extra output classes that we will ignore\n num_classes = self.cfg.data.num_classes\n self.model = TorchVisionODAdapter(\n model, ignored_output_inds=[0, num_classes + 1])\n\n if not self._onnx_mode:\n self.model.to(self.device)\n self.load_init_weights(model_weights_path)","def __init__(self,\n model_fn=None,\n model_dir=None,\n config=None,\n params=None,\n use_tpu=True,\n train_batch_size=None,\n eval_batch_size=None,\n predict_batch_size=None,\n batch_axis=None):\n if config is None or not isinstance(config, tpu_config.RunConfig):\n raise ValueError(\n '`config` must be provided with type `tpu_config.RunConfig`')\n\n if params is not None and any(k in params for k in _RESERVED_PARAMS_KEYS):\n raise ValueError('{} are reserved keys but existed in params {}.'.format(\n _RESERVED_PARAMS_KEYS, params))\n\n if use_tpu:\n # Perform some very basic validations. More validations will be found in\n # _TPUContext.\n if train_batch_size is None:\n raise ValueError('`train_batch_size` cannot be `None`')\n util_lib.check_positive_integer(train_batch_size, 'train_batch_size')\n\n if (config.tpu_config.per_host_input_for_training is\n tpu_config.InputPipelineConfig.PER_SHARD_V1 and\n config.tpu_config.computation_shape):\n raise ValueError(\n 'Model parallelism only supports per host input for training. '\n 'Please adjust TPURunconfig.per_host_input_for_training.')\n\n if eval_batch_size is not None:\n util_lib.check_positive_integer(eval_batch_size, 'eval_batch_size')\n\n if predict_batch_size is not None:\n util_lib.check_positive_integer(predict_batch_size,\n 'predict_batch_size')\n\n # Verifies the model_fn signature according to Estimator framework.\n estimator_lib._verify_model_fn_args(model_fn, params) # pylint: disable=protected-access\n # We cannot store config and params in this constructor as parent\n # constructor might change them, such as assigning a temp dir for\n # config.model_dir.\n model_function = self._augment_model_fn(model_fn, batch_axis)\n\n # Passing non-None params as wrapped model_fn has it.\n params = params or {}\n super(TPUEstimator, self).__init__(\n model_fn=model_function,\n model_dir=model_dir,\n config=config,\n params=params)\n self._iterations_per_training_loop = (\n self._config.tpu_config.iterations_per_loop)\n\n # All properties passed to _TPUContext are immutable.\n # pylint: disable=protected-access\n self._ctx = tpu_context._get_tpu_context(\n self._config, train_batch_size,\n eval_batch_size, predict_batch_size,\n use_tpu)\n\n self._is_input_fn_invoked = None","def set_up_model(dt, model, update = False):\n \n start_scope()\n \n ##### Update model parameters (should be done, if original parameters have been changed)\n if update:\n ###### Temperature in Kelvin\n model.T_kelvin = model.zero_celsius + model.T_celsius*kelvin\n \n ##### Potentials\n # Resting potential (calculated with Goldman equation)\n model.V_res = (model.R*model.T_kelvin)/model.F * np.log((model.P_K*model.n_init**2*model.K_e + model.P_Na*model.h_init*model.m_init**3*model.Na_e)/\\\n (model.P_K*model.n_init**2*model.K_i + model.P_Na*model.h_init*model.m_init**3*model.Na_i))\n \n # Nerst potential for leakage current; leakage chanels were excluded but could be added by using: g_L*(E_L-(v-V_res)) \n model.E_L = (-1/model.g_L)*(model.P_Na*model.m_init**3*model.h_init*(model.V_res*model.F**2)/(model.R*model.T_kelvin) * \\\n (model.Na_e-model.Na_i*exp(model.V_res*model.F/(model.R*model.T_kelvin)))/(1-np.exp(model.V_res*model.F/(model.R*model.T_kelvin))) + \\\n model.P_K*model.n_init**2*(model.V_res*model.F**2)/(model.R*model.T_kelvin) *\\\n (model.K_e-model.K_i*np.exp(model.V_res*model.F/(model.R*model.T_kelvin)))/(1-np.exp(model.V_res*model.F/(model.R*model.T_kelvin))))\n \n \n ##### structure of ANF\n # terminal = 0\n # internode = 1\n # node = 2\n # presomatic region = 3\n # Soma = 4\n # postsomatic region = 5)\n model.structure = np.array(list(np.tile([2,1],model.nof_internodes)) + [2])\n model.nof_comps = len(model.structure)\n \n ##### Compartment lengths\n # initialize\n model.compartment_lengths = np.zeros_like(model.structure)*um\n # length internodes\n model.compartment_lengths[model.structure == 1] = model.length_internodes\n # length nodes\n model.compartment_lengths[model.structure == 2] = model.length_nodes\n # total length neuron\n model.length_neuron = sum(model.compartment_lengths)\n \n ##### Compartment diameters\n # initialize\n model.compartment_diameters = np.zeros(model.nof_comps+1)*um\n # dendrite\n model.fiber_inner_diameter = 0.7* model.fiber_outer_diameter\n model.compartment_diameters[:] = model.fiber_inner_diameter\n \n ##### Compartment middle point distances (needed for plots)\n model.distance_comps_middle = np.zeros_like(model.compartment_lengths)\n model.distance_comps_middle[0] = 0.5*model.compartment_lengths[0]\n for ii in range(0,model.nof_comps-1):\n model.distance_comps_middle[ii+1] = 0.5* model.compartment_lengths[ii] + 0.5* model.compartment_lengths[ii+1]\n \n ##### Capacitivites\n # initialize\n model.c_m = np.zeros_like(model.structure)*uF/cm**2\n # internodes\n model.c_m[np.where(model.structure == 1)] = 0*uF/cm**2\n # nodes\n model.c_m[np.where(model.structure == 2)] = model.c_m_layer\n \n ##### Axoplasmatic resistances\n model.compartment_center_diameters = np.zeros(model.nof_comps)*um\n model.compartment_center_diameters = (model.compartment_diameters[0:-1] + model.compartment_diameters[1:]) / 2 \n model.R_a = (model.compartment_lengths*model.rho_in) / ((model.compartment_center_diameters*0.5)**2*np.pi)\n \n ##### Surface arias\n # lateral surfaces\n m = [np.sqrt(abs(model.compartment_diameters[i+1] - model.compartment_diameters[i])**2 + model.compartment_lengths[i]**2)\n for i in range(0,model.nof_comps)]\n # total surfaces\n model.A_surface = [(model.compartment_diameters[i+1] + model.compartment_diameters[i])*np.pi*m[i]*0.5\n for i in range(0,model.nof_comps)]\n \n ##### Noise term\n model.P_Na_vector = np.zeros(model.nof_comps)*um/second\n model.P_Na_vector[model.structure == 2] = model.P_Na\n model.noise_term = np.sqrt(model.A_surface*model.P_Na_vector)\n \n ##### Compartments to plot\n model.comps_to_plot = range(1,model.nof_comps)\n \n ##### initialize defaultclock\n defaultclock.dt = dt\n\n ##### define morphology\n morpho = Section(n = model.nof_comps,\n length = model.compartment_lengths,\n diameter = model.compartment_diameters)\n \n ##### define neuron\n neuron = SpatialNeuron(morphology = morpho,\n model = model.eqs,\n Cm = model.c_m,\n Ri = model.rho_in,\n method=\"exponential_euler\")\n \n ##### initial values\n neuron.v = model.V_res\n neuron.m = model.m_init\n neuron.n = model.n_init\n neuron.h = model.h_init\n \n ##### Set parameter values of differential equations\n # conductances active compartments\n neuron.g_Na = model.g_Na\n neuron.g_K = model.g_K\n \n # conductances internodes\n neuron.g_Na[np.asarray(np.where(model.structure == 1))] = 0*msiemens/cm**2\n neuron.g_K[np.asarray(np.where(model.structure == 1))] = 0*msiemens/cm**2\n \n # other parameters\n neuron.V_res = model.V_res\n neuron.T_celsius = model.T_celsius\n neuron.E_Na = model.E_Na\n neuron.E_K = model.E_K\n neuron.E_L = model.E_L\n neuron.g_L = model.g_L \n \n return neuron, model","def get_model(model_name: str = \"\", cfg={}) -> torch.nn.Module:\n if model_name == \"default\":\n model = AudioNTT2020(n_mels=cfg.n_mels, d=cfg.feature_d)\n\n elif model_name == \"resnetish34\":\n model = resnetish34()\n\n elif model_name == \"clstm\":\n model = CLSTM()\n\n elif model_name == \"cvt\":\n s1_depth, s2_depth, s3_depth = cfg.depths\n s1_emb_dim, s2_emb_dim, s3_emb_dim = cfg.embed_dims\n s1_mlp_mult, s2_mlp_mult, s3_mlp_mult = cfg.mlp_mults\n\n model = CvT(\n s1_emb_dim=s1_emb_dim,\n s1_depth=s1_depth,\n s1_mlp_mult=s1_mlp_mult,\n s2_emb_dim=s2_emb_dim,\n s2_depth=s2_depth,\n s2_mlp_mult=s2_mlp_mult,\n s3_emb_dim=s3_emb_dim,\n s3_depth=s3_depth,\n s3_mlp_mult=s3_mlp_mult,\n pool=cfg.cvt_pool,\n )\n else:\n raise ValueError(\"Model not found.\")\n return model","def parse_temp_model(self, default=None):\n\t\tcfg_temp_model = self.cfg_root.find('temp_model')\n\n\t\tif cfg_temp_model and cfg_temp_model.text in self.VALID_TEMP_MODEL:\n\t\t\tcfg_temp_model = cfg_temp_model.text\n\t\telse:\n\t\t\tcfg_temp_model = default\n\n\t\treturn cfg_temp_model","def _scaling_model_from_dict(obj):\n for entry_point in pkg_resources.iter_entry_points(\"dxtbx.scaling_model_ext\"):\n if entry_point.name == obj[\"__id__\"]:\n return entry_point.load().from_dict(obj)","def _init_model(\n self,\n cfg: ConfigType,\n weights: Optional[str],\n device: str = 'cpu',\n ) -> nn.Module:\n checkpoint: Optional[dict] = None\n if weights is not None:\n checkpoint = _load_checkpoint(weights, map_location='cpu')\n\n if not cfg:\n assert checkpoint is not None\n try:\n # Prefer to get config from `message_hub` since `message_hub`\n # is a more stable module to store all runtime information.\n # However, the early version of MMEngine will not save config\n # in `message_hub`, so we will try to load config from `meta`.\n cfg_string = checkpoint['message_hub']['runtime_info']['cfg']\n except KeyError:\n assert 'meta' in checkpoint, (\n 'If model(config) is not provided, the checkpoint must'\n 'contain the config string in `meta` or `message_hub`, '\n 'but both `meta` and `message_hub` are not found in the '\n 'checkpoint.')\n meta = checkpoint['meta']\n if 'cfg' in meta:\n cfg_string = meta['cfg']\n else:\n raise ValueError(\n 'Cannot find the config in the checkpoint.')\n cfg.update(\n Config.fromstring(cfg_string, file_format='.py')._cfg_dict)\n\n # Delete the `pretrained` field to prevent model from loading the\n # the pretrained weights unnecessarily.\n if cfg.model.get('pretrained') is not None:\n del cfg.model.pretrained\n\n model = MODELS.build(cfg.model)\n model.cfg = cfg\n self._load_weights_to_model(model, checkpoint, cfg)\n model.to(device)\n model.eval()\n return model","def run_model(config_file):\n config_file = os.path.join(os.getcwd(), config_file)\n result = Tethys(config_file=config_file)\n result.run_model()\n return result","def create_model(config_obj: Union[ModelConfig, dict], random_seed: int = default_random_seed) -> BaseModel:\n if isinstance(config_obj, dict):\n config_obj = ModelConfig.from_dict(config_obj)\n model_type = get_from_registry(config_obj.model_type, model_type_registry)\n return model_type(config_obj, random_seed=random_seed)","def scale_model(model,scaleparname='A',scaleval=1):\n model = get_model_instance(model)\n if scaleparname in model.params:\n scaleparname += '1'\n if isinstance(model,FunctionModel1D):\n compclass = CompositeModel1D\n else:\n compclass = CompositeModel\n res = compclass((model,'constant'),operation='*',\n parnames={'C1':scaleparname})\n setattr(res,scaleparname,scaleval)\n return res","def make(model: Type[Model], **kwargs: Any) -> Model:\n return modelfactory_factory(model)(**kwargs)","def model_fn(features, labels, mode, params): # pylint: disable=unused-argument\n\n tf.logging.info(\"*** Features ***\")\n for name in sorted(features.keys()):\n tf.logging.info(\" name = %s, shape = %s\" % (name, features[name].shape))\n\n input_ids = features[\"input_ids\"]\n input_mask = features[\"input_mask\"]\n segment_ids = features[\"segment_ids\"]\n label_ids = features[\"label_ids\"]\n\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\n\n (total_loss, per_example_loss, logits, probabilities) = model_function.create(\n bert_config, is_training, input_ids, input_mask, segment_ids, label_ids,\n num_labels, use_one_hot_embeddings)\n\n tvars = tf.trainable_variables()\n initialized_variable_names = {}\n scaffold_fn = None\n if init_checkpoint:\n (assignment_map, initialized_variable_names\n ) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\n if use_tpu:\n\n def tpu_scaffold():\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n return tf.train.Scaffold()\n\n scaffold_fn = tpu_scaffold\n else:\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n\n tf.logging.info(\"**** Trainable Variables ****\")\n for var in tvars:\n init_string = \"\"\n if var.name in initialized_variable_names:\n init_string = \", *INIT_FROM_CKPT*\"\n tf.logging.info(\" name = %s, shape = %s%s\", var.name, var.shape,\n init_string)\n\n if mode == tf.estimator.ModeKeys.TRAIN:\n\n train_op = optimization.create_optimizer(\n total_loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu,\n scope=(\"loss\" if model_function.freeze else None))\n\n output_spec = tf.contrib.tpu.TPUEstimatorSpec(\n mode=mode,\n loss=total_loss,\n train_op=train_op,\n scaffold_fn=scaffold_fn)\n elif mode == tf.estimator.ModeKeys.EVAL:\n\n if model_function.task_type == TaskType.CLASSIFICATION:\n\n def metric_fn(per_example_loss, label_ids, logits):\n predictions = tf.argmax(logits, axis=-1, output_type=tf.int32)\n accuracy = tf.metrics.accuracy(label_ids, predictions)\n loss = tf.metrics.mean(per_example_loss)\n return {\n \"eval_accuracy\": accuracy,\n \"eval_loss\": loss,\n }\n elif model_function.task_type == TaskType.REGRESSION:\n\n def metric_fn(per_example_loss, label_ids, logits):\n ground_truth = tf.log1p(tf.clip_by_value(tf.cast(label_ids, tf.float32), 1e-8, 1e+30))\n predictions = tf.log1p(tf.clip_by_value(logits, 1e-8, 1e+30))\n return {\n \"eval_loss\": tf.metrics.mean(per_example_loss),\n \"another_loss\": tf.metrics.mean_squared_error(ground_truth, predictions)\n }\n else:\n raise NotImplementedError()\n\n eval_metrics = (metric_fn, [per_example_loss, label_ids, logits])\n output_spec = tf.contrib.tpu.TPUEstimatorSpec(\n mode=mode,\n loss=total_loss,\n eval_metrics=eval_metrics,\n scaffold_fn=scaffold_fn)\n else:\n predictions = {\n \"result\": probabilities\n }\n print(probabilities.shape)\n print(type(probabilities))\n\n output_spec = tf.contrib.tpu.TPUEstimatorSpec(\n mode=mode, predictions=predictions, scaffold_fn=scaffold_fn)\n return output_spec","def create(name, out_channel, pretrain):\n if out_channel == 10 or out_channel == 100 or out_channel == 200:\n # use custom models\n if name not in custom_factory:\n raise KeyError(\"Unknown model:\", name)\n return custom_factory[name](out_channel)\n elif out_channel == 1000:\n if name not in torchvision_factory:\n raise KeyError(\"Unknown model:\", name)\n return torchvision_factory[name](pretrain)\n else:\n raise Exception","def make_model(self, options, generator):\n model_type = options.model_type\n input_shape = (options.target_size[0], options.target_size[1],\n len(options.active_input_inds))\n nb_labels = generator.dataset.nb_labels\n\n if model_type == CONV_LOGISTIC:\n model = make_conv_logistic(input_shape, nb_labels,\n options.kernel_size)\n elif model_type == FCN_RESNET:\n model = make_fcn_resnet(\n input_shape, nb_labels, options.use_pretraining,\n options.freeze_base)\n elif model_type == DUAL_FCN_RESNET:\n model = make_dual_fcn_resnet(\n input_shape, options.dual_active_input_inds,\n nb_labels, options.use_pretraining, options.freeze_base)\n elif model_type == UNET:\n model = make_unet(input_shape, nb_labels)\n elif model_type == FC_DENSENET:\n model = make_fc_densenet(\n input_shape, nb_labels, drop_prob=options.drop_prob,\n weight_decay=options.weight_decay,\n down_blocks=options.down_blocks,\n up_blocks=options.up_blocks)\n elif model_type in [CONCAT_ENSEMBLE, AVG_ENSEMBLE]:\n models, active_input_inds_list = self.load_ensemble_models(options)\n if model_type == CONCAT_ENSEMBLE:\n model = ConcatEnsemble(\n models, active_input_inds_list, input_shape, nb_labels)\n elif model_type == AVG_ENSEMBLE:\n model = AvgEnsemble(models, active_input_inds_list)\n else:\n raise ValueError('{} is not a valid model_type'.format(model_type))\n\n return model","def model_fn(features, labels, mode, params): # pylint: disable=unused-argument\n\n # tf.logging.info(\"*** Features ***\")\n # for name in sorted(features.keys()):\n # tf.logging.info(\" name = %s, shape = %s\" % (name, features[name].shape))\n\n input_ids = features[\"input_ids\"]\n input_mask = features[\"input_mask\"]\n segment_ids = features[\"segment_ids\"]\n label_ids = features[\"label_ids\"]\n\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\n\n (total_loss, per_example_loss, logits, probabilities) = create_model(\n bert_config, is_training, input_ids, input_mask, segment_ids, label_ids,\n num_labels, use_one_hot_embeddings)\n\n # output_spec = tf.contrib.tpu.TPUEstimatorSpec(\n # mode=tf.estimator.ModeKeys.PREDICT,\n # predictions=probabilities)\n output_spec = tf.estimator.EstimatorSpec(\n mode=tf.estimator.ModeKeys.PREDICT,\n predictions=probabilities\n )\n return output_spec","def model_fn(features, labels, mode, params):\n utils.log(\"Building model...\")\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\n model = FinetuningModel(\n config, tasks, is_training, features, num_train_steps)\n\n if pretraining_config is not None:\n # init_checkpoint = tf.train.latest_checkpoint(pretraining_config.model_dir)\n init_checkpoint = pretraining_config['checkpoint']\n utils.log(\"Using checkpoint\", init_checkpoint)\n tvars = tf.trainable_variables()\n scaffold_fn = None\n if init_checkpoint:\n assignment_map, _ = modeling.get_assignment_map_from_checkpoint(\n tvars, init_checkpoint)\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n\n # Build model for training or prediction\n if mode == tf.estimator.ModeKeys.TRAIN:\n train_op = optimization.create_optimizer(\n model.loss, config.learning_rate, num_train_steps,\n weight_decay_rate=config.weight_decay_rate,\n use_tpu=config.use_tpu,\n warmup_proportion=config.warmup_proportion,\n layerwise_lr_decay_power=config.layerwise_lr_decay,\n n_transformer_layers=model.bert_config.num_hidden_layers\n )\n output_spec = tf.estimator.tpu.TPUEstimatorSpec(\n mode=mode,\n loss=model.loss,\n train_op=train_op,\n scaffold_fn=scaffold_fn,\n training_hooks=[training_utils.ETAHook(\n {} if config.use_tpu else dict(loss=model.loss),\n num_train_steps, config.iterations_per_loop, config.use_tpu, 10)])\n else:\n assert mode == tf.estimator.ModeKeys.PREDICT\n output_spec = tf.estimator.tpu.TPUEstimatorSpec(\n mode=mode,\n predictions=utils.flatten_dict(model.outputs),\n scaffold_fn=scaffold_fn)\n\n utils.log(\"Building complete\")\n return output_spec","def transformerXLModel(*args, **kwargs):\n model = TransfoXLModel.from_pretrained(*args, **kwargs)\n return model","def CreateModel(self, request, timeout, metadata=None, with_call=False, protocol_options=None):\n raise NotImplementedError()","def create_supervised_evaluator(\n model, prepare_batch, metrics=None, device=None, non_blocking=False, output_transform=val_transform,\n):\n metrics = metrics or {}\n\n if device:\n model.to(device)\n\n def _inference(engine, batch):\n model.eval()\n with torch.no_grad():\n x, y, ids, patch_locations = prepare_batch(batch, device=device, non_blocking=non_blocking)\n y_pred = model(x)\n y_pred = _upscale_model_output(y_pred, x)\n return output_transform(x, y, y_pred, ids, patch_locations)\n\n engine = Engine(_inference)\n\n for name, metric in metrics.items():\n metric.attach(engine, name)\n\n return engine","def createModel(config_path, checkpoint_path, graph_path):\n\n global build_graph, prev_classes\n\n trt_graph = None\n input_names = None\n \n if build_graph:\n frozen_graph, input_names, output_names = build_detection_graph(\n config=config_path,\n checkpoint=checkpoint_path\n )\n \n trt_graph = trt.create_inference_graph(\n input_graph_def=frozen_graph,\n outputs=output_names,\n max_batch_size=1,\n max_workspace_size_bytes=1 << 25,\n precision_mode='FP16',\n minimum_segment_size=50\n )\n\n with open(graph_path, 'wb') as f:\n f.write(trt_graph.SerializeToString())\n\n with open('config.txt', 'r+') as json_file: \n data = json.load(json_file)\n data['model'] = []\n data['model'] = [{'input_names': input_names}]\n json_file.seek(0)\n json_file.truncate()\n json.dump(data, json_file)\n\n else:\n with open(graph_path, 'rb') as f:\n trt_graph = tf.GraphDef()\n trt_graph.ParseFromString(f.read())\n with open('config.txt') as json_file: \n data = json.load(json_file)\n input_names = data['model'][0]['input_names']\n\n return Model(trt_graph, input_names)","def recent_model_init(model_args, task_infos, tokenizer):\n config = AutoConfig.from_pretrained(\n model_args.model_name_or_path,\n num_labels=task_infos.num_labels,\n cache_dir=model_args.model_cache_dir,\n id2label=task_infos.id2label,\n label2id=task_infos.label2id,\n )\n config.dense_type = model_args.dense_type\n config.act_type = model_args.act_type\n config.num_labels_per_head = [\n len(label_id) for label_id in task_infos.head_id_to_label_id\n ]\n config.head2label = task_infos.head_id_to_label_id\n model_cls = getattr(mod, model_args.architectures,\n RobertaForKlueRecent)\n model = model_cls.from_pretrained(\n model_args.model_name_or_path,\n config=config,\n cache_dir=model_args.model_cache_dir,\n )\n if model.config.vocab_size < len(tokenizer):\n print(\"resize...\")\n model.resize_token_embeddings(len(tokenizer))\n return model","def initialize_model_from_cfg(args, gpu_id=0):\n model = eval(args.model).loot_model(args)\n model.eval()\n\n if args.cuda:\n model.cuda()\n\n if args.load_ckpt:\n load_name = args.load_ckpt\n logger.info(\"loading checkpoint %s\", load_name)\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\n net_utils.load_ckpt(model, checkpoint['model'])\n\n if args.load_detectron:\n logger.info(\"loading detectron weights %s\", args.load_detectron)\n load_detectron_weight(model, args.load_detectron)\n\n\n return model","def create_model(self):\r\n model = self.model_fn(self.flags)\r\n print(model)\r\n return model","def optimize_model(input,\n model_type='bert',\n num_heads=0,\n hidden_size=0,\n optimization_options=None,\n opt_level=0,\n use_gpu=False,\n only_onnxruntime=False):\n (optimizer_class, producer, run_onnxruntime) = MODEL_CLASSES[model_type]\n\n temp_model_path = None\n if opt_level > 1: # Optimization specified for an execution provider.\n temp_model_path = optimize_by_onnxruntime(input, use_gpu=use_gpu, opt_level=opt_level)\n elif run_onnxruntime:\n # Use Onnxruntime to do optimizations (like constant folding and cast elimation) that is not specified to exection provider.\n # CPU provider is used here so that there is no extra node for GPU memory copy.\n temp_model_path = optimize_by_onnxruntime(input, use_gpu=False, opt_level=1)\n\n model = load_model(temp_model_path or input, format=None, load_external_data=True)\n\n if model.producer_name and producer != model.producer_name:\n logger.warning(\n f\"Model producer not matched: Expect {producer}, Got {model.producer_name} {model.producer_version}. Please specify correct --model_type parameter.\"\n )\n\n if optimization_options is None:\n optimization_options = BertOptimizationOptions(model_type)\n\n optimizer = optimizer_class(model, num_heads, hidden_size)\n\n if not only_onnxruntime:\n optimizer.optimize(optimization_options)\n\n # Remove the temporary model.\n if temp_model_path:\n os.remove(temp_model_path)\n logger.debug(\"Remove tempoary model: {}\".format(temp_model_path))\n\n optimizer.model.producer_name = \"onnxruntime.transformers\"\n from onnxruntime import __version__ as onnxruntime_version\n optimizer.model.producer_version = onnxruntime_version\n\n return optimizer","def generate_model(**kwargs):\n model = ResNet3D(Bottleneck, [3, 4, 6, 3], [64, 128, 256, 512], **kwargs)\n return model","def basic_model_init(model_args, task_infos, tokenizer):\n config = AutoConfig.from_pretrained(\n model_args.model_name_or_path,\n num_labels=task_infos.num_labels,\n cache_dir=model_args.model_cache_dir,\n id2label=task_infos.id2label,\n label2id=task_infos.label2id,\n )\n model_cls = getattr(mod, model_args.architectures,\n AutoModelForSequenceClassification)\n model = model_cls.from_pretrained(\n model_args.model_name_or_path,\n config=config,\n cache_dir=model_args.model_cache_dir,\n )\n if model.config.vocab_size < len(tokenizer):\n print(\"resize...\")\n model.resize_token_embeddings(len(tokenizer))\n return model","def model_creator(config):\n return nn.Linear(1, 1)","def set_temperature(logits, label):\n nll_criterion = nn.CrossEntropyLoss().to(device)\n\n class TemperatureModel(nn.Module):\n def __init__(self):\n super().__init__()\n self.temperature = nn.Parameter(torch.ones(1) * 1.5)\n\n def forward(self, logits):\n temperature = self.temperature.unsqueeze(1).expand(logits.size(0), logits.size(1))\n logits = logits / temperature\n return logits, self.temperature\n\n model_T = TemperatureModel()\n optimizer = optim.Adam(\n model_T.parameters(), lr=0.01, weight_decay=1e-4\n )\n for i in range(40):\n TC_pred, _ = model_T(logits)\n optimizer.zero_grad()\n loss = nll_criterion(TC_pred, label)\n loss.backward()\n optimizer.step()\n\n _, T = model_T(logits)\n return T","def create_model(self):\n pass","def create_model(self):\n pass","def _make_model_v1():\n tf.reset_default_graph()\n\n with tf.Session() as sess:\n # Make two simple graphs, both of which will be served by TF\n x = tf.placeholder('float', shape=(None, 3), name='Input')\n z = tf.placeholder('float', shape=(), name='ScalarMultiple')\n m = tf.Variable([1.0, 1.0, 1.0], name='Slopes')\n y = m * x + 1\n len_fun = tf.reduce_sum(y - x) # Returns the number of elements in the array\n scale_mult = tf.multiply(z, x, name='scale_mult')\n\n # Initialize the variables\n init = tf.global_variables_initializer()\n sess.run(init)\n\n # Create the tool for saving the model to disk\n builder = tf.saved_model.builder.SavedModelBuilder(tf_export_path)\n\n # Make descriptions for the inputs and outputs\n x_desc = tf.saved_model.utils.build_tensor_info(x)\n y_desc = tf.saved_model.utils.build_tensor_info(y)\n z_desc = tf.saved_model.utils.build_tensor_info(z)\n len_fun_desc = tf.saved_model.utils.build_tensor_info(len_fun)\n scale_mult_desc = tf.saved_model.utils.build_tensor_info(scale_mult)\n\n # Make a signature for the functions to be served\n func_sig = tf.saved_model.signature_def_utils.build_signature_def(\n inputs={'x': x_desc},\n outputs={'y': y_desc},\n method_name='run'\n )\n len_sig = tf.saved_model.signature_def_utils.build_signature_def(\n inputs={'x': x_desc},\n outputs={'len': len_fun_desc},\n method_name='length'\n )\n mult_sig = tf.saved_model.signature_def_utils.build_signature_def(\n inputs={'x': x_desc, 'z': z_desc},\n outputs={'scale_mult': scale_mult_desc},\n method_name='scalar_multiply'\n )\n\n # Add the functions and the state of the graph to the builder\n builder.add_meta_graph_and_variables(\n sess, [tf.saved_model.tag_constants.SERVING],\n signature_def_map={\n tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: func_sig,\n 'length': len_sig,\n 'scalar_multiply': mult_sig\n })\n\n # Save the function\n builder.save()","def from_pretrained(cls,\n *args,\n **kwargs):\n pretrained_model_name_or_path = kwargs.get(\"pretrained_model_name_or_path\", None) \\\n if len(args) == 0 else args[0]\n config_dict, _ = PretrainedConfig.get_config_dict(pretrained_model_name_or_path)\n bigdl_transformers_low_bit = config_dict.pop(\"bigdl_transformers_low_bit\", False)\n invalidInputError(not bigdl_transformers_low_bit,\n f\"Detected model is a low-bit({bigdl_transformers_low_bit}) model, \"\n f\"Please use load_low_bit to load this model.\")\n\n # For huggingface transformers cls.HF_Model.from_pretrained could only restore the model\n # in the original format, which is not quantized,\n # we can convert the model to quantized later.\n load_in_4bit = kwargs.pop(\"load_in_4bit\", False)\n load_in_low_bit = kwargs.pop(\"load_in_low_bit\", None)\n optimize_model = kwargs.pop(\"optimize_model\", True)\n\n if load_in_4bit or load_in_low_bit:\n # load int x-bit\n kwargs[\"low_cpu_mem_usage\"] = True\n # set default torch_dtype='auto'\n kwargs[\"torch_dtype\"] = kwargs.get(\"torch_dtype\", 'auto')\n # Avoid tensor parallel F.Linear Operations\n if \"pretraining_tp\" in config_dict:\n kwargs[\"pretraining_tp\"] = 1\n q_k = load_in_low_bit if load_in_low_bit else \"sym_int4\"\n model = cls.load_convert(q_k, optimize_model, *args, **kwargs)\n else:\n # load default\n model = cls.HF_Model.from_pretrained(*args, **kwargs)\n\n return model","def set_temperature2(logits, label):\n\n nll_criterion = nn.CrossEntropyLoss().to(device)\n\n class TemperatureModel(nn.Module):\n def __init__(self):\n super().__init__()\n self.temperature = nn.Parameter(torch.ones(1) * 1.5)\n\n def forward(self, logits):\n temperature = self.temperature.unsqueeze(1).expand(logits.size(0), logits.size(1))\n logits = logits / temperature\n return logits, self.temperature\n\n model_T = TemperatureModel()\n optimizer = optim.Adam(\n model_T.parameters(), lr=0.01, weight_decay=1e-4\n )\n for i in range(40):\n TC_pred, _ = model_T(logits)\n optimizer.zero_grad()\n loss = nll_criterion(TC_pred, label)\n loss.backward()\n optimizer.step()\n\n _, T = model_T(logits)\n return T"],"string":"[\n \"def create_model(self) -> None:\\n self._model = create_model_with_temperature_scaling(self.config)\",\n \"def do_create_model(**kwargs):\\n model_params = {\\n 'name': kwargs['dag_run'].conf.get('model_name'),\\n 'description': 'A custom DNN regressor model',\\n 'regions': [REGION]\\n }\\n\\n ti = kwargs['ti']\\n\\n is_model = ti.xcom_pull(key='is_project', task_ids='check_model')\\n if not is_model:\\n mle = MLEngineHook()\\n mle.create_model(PROJECT, model_params)\",\n \"def model(self, **config_kwargs):\\n measurement = self.get_measurement(**config_kwargs)\\n log.debug(\\n 'model being created for measurement {0:s}'.format(measurement['name'])\\n )\\n\\n patches = config_kwargs.get('patches', [])\\n\\n modelspec = {\\n 'channels': self.spec['channels'],\\n 'parameters': measurement['config']['parameters'],\\n }\\n for patch in patches:\\n modelspec = jsonpatch.JsonPatch(patch).apply(modelspec)\\n\\n return Model(modelspec, poiname=measurement['config']['poi'], **config_kwargs)\",\n \"def create(model: TModel) -> ModelTransformer:\\n model_backend = get_backend(model)\\n if model_backend == BackendType.ONNX:\\n from nncf.onnx.graph.model_transformer import ONNXModelTransformer\\n\\n return ONNXModelTransformer(model)\\n if model_backend == BackendType.OPENVINO:\\n from nncf.openvino.graph.model_transformer import OVModelTransformer\\n\\n return OVModelTransformer(model)\\n if model_backend == BackendType.TORCH:\\n from nncf.torch.model_transformer import PTModelTransformer\\n\\n return PTModelTransformer(model)\\n raise RuntimeError(\\n \\\"Cannot create backend-specific model transformer because {} is not supported!\\\".format(model_backend)\\n )\",\n \"def create_scaling_model(params, experiments, reflections):\\n autos = [None, Auto, \\\"auto\\\", \\\"Auto\\\"]\\n use_auto_model = params.model in autos\\n # Determine non-auto model to use outside the loop over datasets.\\n if not use_auto_model:\\n model_class = None\\n for entry_point in pkg_resources.iter_entry_points(\\\"dxtbx.scaling_model_ext\\\"):\\n if entry_point.name == params.model:\\n model_class = entry_point.load()\\n break\\n if not model_class:\\n raise ValueError(f\\\"Unable to create scaling model of type {params.model}\\\")\\n\\n for expt, refl in zip(experiments, reflections):\\n if not expt.scaling_model or params.overwrite_existing_models:\\n # need to make a new model\\n if use_auto_model:\\n if not expt.scan:\\n model = KBScalingModel\\n else: # set model as physical unless scan < 1.0 degree\\n osc_range = expt.scan.get_oscillation_range()\\n abs_osc_range = abs(osc_range[1] - osc_range[0])\\n if abs_osc_range < 1.0:\\n model = KBScalingModel\\n else:\\n model = PhysicalScalingModel\\n else:\\n model = model_class\\n expt.scaling_model = model.from_data(params, expt, refl)\\n else:\\n # allow for updating of an existing model.\\n expt.scaling_model.update(params)\\n return experiments\",\n \"def calibrate_temperature(task_id, data, mnet, hnet, hhnet, device, config,\\n shared, logger, writer, cal_per_model=False,\\n only_correctly_classified=False,\\n cal_target_entropy=-1):\\n logger.info('Temperature calibration for task %d ...' % (task_id+1))\\n\\n # FIXME We could also follow the code from\\n # https://github.com/gpleiss/temperature_scaling/blob/master/temperature_scaling.py\\n # but they don't consider BNNs. Note, there code is much more efficient\\n # since they compute the logits before entering the training loop (which\\n # is possible when only having one model). Though, in general, we have\\n # multiple models.\\n\\n set_train_mode(True, mnet, hnet, hhnet, None)\\n\\n gauss_main = False\\n if isinstance(mnet, GaussianBNNWrapper):\\n gauss_main = True\\n\\n # Whether the hypernet represents an implicit distribution (i.e., it's\\n # input is a random variable), or whether it has task embeddings as input.\\n det_hnet = False\\n if hnet is not None:\\n if hnet.num_known_conds > 0:\\n assert hhnet is None\\n\\n det_hnet = True\\n # Can currently only be the case if we train a BbB setup with option\\n # `mean_only` enabled.\\n if not gauss_main:\\n assert hasattr(config, 'mean_only') and config.mean_only\\n\\n # The single parameter to be tuned by this method.\\n temp_param = torch.nn.Parameter(shared.softmax_temp[task_id],\\n requires_grad=True)\\n assert temp_param == 1.\\n\\n # Which temperature transfer function to use during training. Note, this\\n # can ensure that temperatures don't become negative.\\n # ttf = temperature transfer function\\n ttf_choice = 'softplus'\\n if ttf_choice == 'linear':\\n ttf = lambda x : x\\n #torch.nn.init.ones_(temp_param.data)\\n elif ttf_choice == 'exp':\\n ttf = torch.exp\\n torch.nn.init.zeros_(temp_param.data)\\n else:\\n ttf = F.softplus\\n temp_param.data = torch.log(torch.exp(torch.ones(1)) - \\\\\\n torch.ones(1)).to(device)\\n\\n allowed_outputs = pmutils.out_units_of_task(config, data, task_id,\\n config.num_tasks)\\n\\n optimizer = tutils.get_optimizer([temp_param], config.lr,\\n momentum=config.momentum, weight_decay=config.weight_decay,\\n use_adam=config.use_adam, adam_beta1=config.adam_beta1,\\n use_rmsprop=config.use_rmsprop, use_adadelta=config.use_adadelta,\\n use_adagrad=config.use_adagrad)\\n\\n mnet_kwargs = pmutils.mnet_kwargs(config, task_id, mnet)\\n\\n num_w_samples = config.train_sample_size if config.cal_sample_size == -1 \\\\\\n else config.cal_sample_size\\n\\n with torch.no_grad():\\n # We don't change any network parameters, so these calls produce\\n # constant outputs.\\n theta_current = None\\n if hhnet is not None:\\n theta_current = hhnet.forward(cond_id=task_id)\\n theta_current = [p.detach() for p in theta_current]\\n\\n if gauss_main:\\n assert hhnet is None\\n\\n if hnet is not None:\\n hnet_out = hnet.forward(cond_id=task_id)\\n else:\\n hnet_out = None\\n w_mean, w_rho = mnet.extract_mean_and_rho(weights=hnet_out)\\n w_std = putils.decode_diag_gauss(w_rho,\\n logvar_enc=mnet.logvar_encoding)\\n\\n elif det_hnet:\\n w_mean = hnet.forward(cond_id=task_id)\\n\\n ### We first compute the logit outputs over all samples for all models,\\n ### since they don't change anymore.\\n # FIXME Could lead to memory issues for large datasets and might not be\\n # inefficient if ``config.cal_temp_iter`` is small, since we won't\\n # iterate over the whole dataset.\\n inputs = data.get_train_inputs()\\n targets = data.get_train_outputs()\\n\\n T = data.output_to_torch_tensor(targets, device, mode='train')\\n # Modify 1-hot encodings according to CL scenario.\\n assert T.shape[1] == data.num_classes\\n # In CL1, CL2 and CL3 (with seperate heads) we do not have to modify the\\n # targets.\\n if config.cl_scenario == 3 and not config.split_head_cl3:\\n raise NotImplementedError('Temperature calibration not ' +\\n 'implemented for CL3 without split-head.')\\n\\n _, labels = torch.max(T, 1) # Integer labels.\\n #labels = labels.detach()\\n\\n num_samples = inputs.shape[0]\\n\\n logit_outputs = torch.empty((num_w_samples, num_samples, T.shape[1])). \\\\\\n to(device)\\n\\n for j in range(num_w_samples):\\n if gauss_main: # Gaussian weight posterior.\\n # In case of the local-reparam trick, we anyway have a different\\n # weight per sample. So, the demand of having the same model for\\n # all samples in the dataset drops.\\n if config.local_reparam_trick:\\n # Note, the sampling will happen inside the forward method.\\n weights = None\\n emean = w_mean\\n erho = w_rho\\n else:\\n weights = putils.sample_diag_gauss(w_mean, w_std,\\n is_radial=config.radial_bnn)\\n emean = None\\n erho = None\\n\\n elif det_hnet:\\n weights = w_mean\\n\\n else:\\n if hnet is not None: # Implicit hypernetwork.\\n z = torch.normal(torch.zeros(1, shared.noise_dim),\\n config.latent_std).to(device)\\n weights = hnet.forward(uncond_input=z,\\n weights=theta_current)\\n else: # Main network only training.\\n weights = None\\n\\n # I use the validation batch size on purpose, since it is usually\\n # bigger and we just want to quickly compute the logits.\\n curr_bs = config.val_batch_size\\n n_processed = 0\\n\\n while n_processed < num_samples:\\n if n_processed + curr_bs > num_samples:\\n curr_bs = num_samples - n_processed\\n n_processed += curr_bs\\n\\n sind = n_processed - curr_bs\\n eind = n_processed\\n\\n ### Compute negative log-likelihood (NLL).\\n X = data.input_to_torch_tensor(inputs[sind:eind, :], device,\\n mode='train')\\n\\n if gauss_main:\\n Y = mnet.forward(X, weights=None, mean_only=False,\\n extracted_mean=emean, extracted_rho=erho,\\n sample=weights, **mnet_kwargs)\\n else:\\n Y = mnet.forward(X, weights=weights, **mnet_kwargs)\\n\\n if allowed_outputs is not None:\\n Y = Y[:, allowed_outputs]\\n\\n logit_outputs[j, sind:eind, :] = Y\\n\\n # Since we computed all training logits, we might as well compute\\n # the training accuracy on the predictive distributions at temperature 1\\n # (note, temperature doesn't change predicted labels).\\n pred_dists = F.softmax(logit_outputs, dim=2).mean(dim=0)\\n assert pred_dists.ndim == 2\\n _, pred_labels = torch.max(pred_dists, 1)\\n train_acc = 100. * torch.sum(pred_labels == labels) / num_samples\\n logger.debug('Task %d -- training accuracy: %.2f%%.' % \\\\\\n (task_id+1, train_acc))\\n\\n log_pred_dists = torch.log(torch.clamp(pred_dists, min=1e-5))\\n in_entropies = -torch.sum(pred_dists * log_pred_dists, dim=1)\\n\\n # Normalize by maximum entropy.\\n max_ent = - np.log(1.0 / data.num_classes)\\n in_entropies /= max_ent\\n\\n in_entropies_mean = in_entropies.mean()\\n in_entropies_std = in_entropies.std()\\n logger.debug('Task %d -- training in-dist. entropy: %f.' % \\\\\\n (task_id+1, in_entropies_mean))\\n\\n if not hasattr(shared, 'train_in_ent_mean'):\\n shared.train_in_ent_mean = []\\n shared.train_in_ent_std = []\\n shared.train_in_ent_mean.append( \\\\\\n in_entropies_mean.detach().cpu().numpy())\\n shared.train_in_ent_std.append(in_entropies_std.detach().cpu().numpy())\\n\\n if only_correctly_classified:\\n num_correct = torch.sum(pred_labels == labels)\\n\\n logger.info('Task %d -- only using %d/%d correctly classified ' \\\\\\n % (task_id+1, num_correct, num_samples) + \\\\\\n 'samples for calibration.')\\n\\n logit_outputs = logit_outputs[:, pred_labels == labels, :]\\n num_samples = num_correct\\n assert logit_outputs.shape[1] == num_correct\\n\\n labels = labels[pred_labels == labels]\\n assert labels.shape[0] == num_correct\\n\\n # Sanity check!\\n pred_dists = F.softmax(logit_outputs, dim=2).mean(dim=0)\\n _, pred_labels = torch.max(pred_dists, 1)\\n assert torch.sum(pred_labels == labels) == num_correct\\n\\n logit_outputs = logit_outputs.detach()\\n\\n ### Calibrate temperature.\\n for i in range(config.cal_temp_iter):\\n optimizer.zero_grad()\\n\\n batch_inds = np.random.randint(0, num_samples, config.batch_size)\\n\\n batch_logits = logit_outputs[:, batch_inds, :]\\n batch_labels = labels[batch_inds]\\n assert batch_logits.ndim == 3\\n\\n # Note, this first option is more numerically stable when calibrating NLL.\\n if cal_per_model or num_w_samples == 1:\\n loss = 0\\n for j in range(num_w_samples):\\n if cal_target_entropy != -1:\\n batch_sm = F.softmax(batch_logits[j, :, :] / \\\\\\n ttf(temp_param), dim=1)\\n # For numerical stability.\\n batch_log_sm = torch.log(torch.clamp(batch_sm, min=1e-5))\\n\\n # Mean entropy within the batch.\\n batch_entropy = -torch.sum(batch_sm * batch_log_sm,\\n dim=1).mean()\\n\\n loss += (batch_entropy - cal_target_entropy)**2\\n else: # Compute NLL loss\\n # Note, softmax will be computed inside the `cross_entropy`.\\n loss += F.cross_entropy( \\\\\\n batch_logits[j, :, :] / ttf(temp_param), batch_labels,\\n reduction='mean')\\n loss /= num_w_samples\\n\\n else:\\n batch_pred_dist = F.softmax(batch_logits / ttf(temp_param),\\n dim=2).mean(dim=0)\\n # FIXME nll_loss expects log_softmax as input. To compute the\\n # predictive distribution, we have to first average softmax outputs\\n # before we can apply the log, which might lead to numerical\\n # instabilities.\\n #batch_log_pd = batch_pred_dist\\n #batch_log_pd[batch_pred_dist < 1e-5] = 1e-5\\n batch_log_pd = torch.clamp(batch_pred_dist, min=1e-5)\\n batch_log_pd = torch.log(batch_log_pd)\\n if cal_target_entropy != -1:\\n # Mean entropy within the batch.\\n batch_entropy = -torch.sum(batch_pred_dist * batch_log_pd,\\n dim=1).mean()\\n\\n loss += (batch_entropy - cal_target_entropy)**2\\n else: # Compute NLL loss\\n loss = F.nll_loss(batch_log_pd, batch_labels, reduction='mean')\\n\\n loss.backward()\\n if config.clip_grad_value != -1:\\n torch.nn.utils.clip_grad_value_(optimizer.param_groups[0]['params'],\\n config.clip_grad_value)\\n elif config.clip_grad_norm != -1:\\n torch.nn.utils.clip_grad_norm_(optimizer.param_groups[0]['params'],\\n config.clip_grad_norm)\\n optimizer.step()\\n\\n if ttf_choice == 'linear':\\n # NOTE In this case, nothing prevents the temperature from going\\n # negative (e.g., when starting with a large learning rate).\\n # Therefore, we have to actively capture this case.\\n temp_param.data = torch.clamp(temp_param, min=1e-5)\\n\\n if i % 50 == 0:\\n writer.add_scalar('cal/task_%d/loss' % task_id, loss, i)\\n writer.add_scalar('cal/task_%d/temp' % task_id,\\n ttf(temp_param), i)\\n\\n final_temp = ttf(temp_param).data\\n shared.softmax_temp[task_id] = final_temp.data\\n\\n logger.info('Calibrated softmax temperature of task %d is: %f.' % \\\\\\n (task_id+1, final_temp))\\n\\n logger.info('Temperature calibration for task %d ... Done' % (task_id+1))\",\n \"def create(self, req, body):\\n context = req.environ['meteos.context']\\n\\n if not self.is_valid_body(body, 'model'):\\n raise exc.HTTPUnprocessableEntity()\\n\\n model = body['model']\\n\\n LOG.debug(\\\"Create model with request: %s\\\", model)\\n\\n try:\\n experiment = self.engine_api.get_experiment(\\n context, model['experiment_id'])\\n utils.is_valid_status(experiment.__class__.__name__,\\n experiment.status,\\n constants.STATUS_AVAILABLE)\\n template = self.engine_api.get_template(\\n context, experiment.template_id)\\n except exception.NotFound:\\n raise exc.HTTPNotFound()\\n except exception.InvalidStatus:\\n raise\\n\\n display_name = model.get('display_name')\\n display_description = model.get('display_description')\\n experiment_id = model.get('experiment_id')\\n source_dataset_url = model.get('source_dataset_url')\\n dataset_format = model.get('dataset_format', 'csv')\\n model_type = model.get('model_type')\\n model_params = model.get('model_params')\\n swift_tenant = model.get('swift_tenant')\\n swift_username = model.get('swift_username')\\n swift_password = model.get('swift_password')\\n\\n new_model = self.engine_api.create_model(context,\\n display_name,\\n display_description,\\n source_dataset_url,\\n dataset_format,\\n model_type,\\n model_params,\\n template.id,\\n template.job_template_id,\\n experiment_id,\\n experiment.cluster_id,\\n swift_tenant,\\n swift_username,\\n swift_password)\\n\\n return self._view_builder.detail(req, new_model)\",\n \"def create_shunt_model(self):\\r\\n\\r\\n print('\\\\nCreate shunt model')\\r\\n\\r\\n if not self.original_model:\\r\\n raise ValueError('Original model not yet initialized! Either call create_original_model or set it manually.')\\r\\n if not self.shunt_params:\\r\\n raise ValueError('No parameters found in config for shunt model! Create the field [SHUNT_MODEL]')\\r\\n\\r\\n logging.info('')\\r\\n logging.info('#######################################################################################################')\\r\\n logging.info('############################################ SHUNT MODEL ##############################################')\\r\\n logging.info('#######################################################################################################')\\r\\n logging.info('')\\r\\n\\r\\n dilation_rate_input, dilation_rate_output = find_input_output_dilation_rates(self.original_model, self.shunt_params['locations'])\\r\\n\\r\\n print('Used dilation rates: {}'.format(Architectures.get_dilation_rates(self.shunt_params['arch'], dilation_rate_input, dilation_rate_output)))\\r\\n logging.info('Creating shunt with dilation rates: {}'.format(Architectures.get_dilation_rates(self.shunt_params['arch'], dilation_rate_input, dilation_rate_output)))\\r\\n logging.info('')\\r\\n\\r\\n with self.activate_distribution_scope():\\r\\n if self.shunt_params['from_file']:\\r\\n self.shunt_model = keras.models.load_model(self.shunt_params['filepath'])\\r\\n print('Shunt model loaded successfully!')\\r\\n else:\\r\\n input_shape_shunt = self.original_model.get_layer(index=self.shunt_params['locations'][0]).input_shape[1:]\\r\\n if isinstance(input_shape_shunt, list):\\r\\n input_shape_shunt = input_shape_shunt[0][1:]\\r\\n output_shape_shunt = self.original_model.get_layer(index=self.shunt_params['locations'][1]).output_shape[1:]\\r\\n if isinstance(output_shape_shunt, list):\\r\\n output_shape_shunt = output_shape_shunt[0][1:]\\r\\n\\r\\n self.shunt_model = Architectures.createShunt(input_shape_shunt,\\r\\n output_shape_shunt,\\r\\n arch=self.shunt_params['arch'],\\r\\n use_se=False,\\r\\n dilation_rate_input=dilation_rate_input,\\r\\n dilation_rate_output=dilation_rate_output,\\r\\n expansion_factor=1.0)\\r\\n\\r\\n if self.shunt_params['pretrained']:\\r\\n self.shunt_model.load_weights(self.shunt_params['weightspath'])\\r\\n print('Shunt weights loaded successfully!')\\r\\n\\r\\n self.shunt_model.summary(print_fn=self.logger.info, line_length=150)\\r\\n\\r\\n keras.models.save_model(self.shunt_model, Path(self.folder_name_logging, \\\"shunt_model.h5\\\"))\\r\\n logging.info('')\\r\\n logging.info('Shunt model saved to {}'.format(self.folder_name_logging))\\r\\n\\r\\n # calculate flops\\r\\n flops_shunt = calculate_flops_model(self.shunt_model)\\r\\n self.flops_dict['shunt'] = flops_shunt\\r\\n logging.info('')\\r\\n logging.info('FLOPs of shunt model: {}'.format(flops_shunt))\",\n \"def create_model(self, model_config):\\n\\n return self.conn.create_model(\\n **model_config)\",\n \"def create_model(config, rng, example_batch):\\n example_batch = train_utils.prepare_example_batch(example_batch)\\n\\n key0, rng = random.split(rng, 2)\\n model, variables, metric_collector = MODEL_DICT[config.model.name](\\n key0, example_batch, config\\n )\\n\\n return model, variables, metric_collector\",\n \"def setup_model(msid, t0, t1, model_spec, init):\\n\\n model = xija.ThermalModel(msid, start=t0, stop=t1, model_spec=model_spec)\\n for key, value in init.items():\\n if isinstance(value, dict):\\n model.comp[key].set_data(value['data'], value['times'])\\n else:\\n model.comp[key].set_data(value)\\n\\n return model\",\n \"def setup_model(msid, t0, t1, model_spec, init):\\n\\n model = xija.ThermalModel(msid, start=t0, stop=t1, model_spec=model_spec)\\n for key, value in init.items():\\n if isinstance(value, dict):\\n model.comp[key].set_data(value['data'], value['times'])\\n else:\\n model.comp[key].set_data(value)\\n\\n return model\",\n \"def create(self) -> tf.keras.models.Model:\\n raise NotImplementedError()\",\n \"def create_model(model_name, random_state, epoch, device, log_path, **hparams):\\n model = eval(f'{model_name}')(\\n **hparams, epoch=int(epoch), random_state=random_state, device=device,\\n log_path=log_path\\n )\\n\\n return model\",\n \"def get_model(model_name, model_config, to_cuda,\\n uniform_initialize_bn_weight=False, forward_is_infer=False):\\n model = None\\n if model_name == 'Tacotron2':\\n if forward_is_infer:\\n class Tacotron2__forward_is_infer(Tacotron2):\\n def forward(self, inputs, input_lengths):\\n return self.infer(inputs, input_lengths)\\n model = Tacotron2__forward_is_infer(**model_config)\\n else:\\n model = Tacotron2(**model_config)\\n elif model_name == 'WaveGlow':\\n if forward_is_infer:\\n class WaveGlow__forward_is_infer(WaveGlow):\\n def forward(self, spect, sigma=1.0):\\n return self.infer(spect, sigma)\\n model = WaveGlow__forward_is_infer(**model_config)\\n else:\\n model = WaveGlow(**model_config)\\n else:\\n raise NotImplementedError(model_name)\\n\\n if uniform_initialize_bn_weight:\\n init_bn(model)\\n\\n if to_cuda:\\n model = model.cuda()\\n return model\",\n \"def _model_fn(features, labels, mode, config):\\n return _transformer_model_fn(\\n features=features,\\n labels=labels,\\n mode=mode,\\n head=head_lib._regression_head_with_mean_squared_error_loss(\\n label_dimension=label_dimension,\\n weight_column=weight_column,\\n loss_reduction=loss_reduction),\\n num_layers=num_layers,\\n d_model=d_model,\\n num_heads=num_heads,\\n dff=dff,\\n input_vocab_size=input_vocab_size,\\n target_vocab_size=target_vocab_size,\\n output_size=output_size,\\n feature_columns=tuple(feature_columns or []),\\n optimizer=optimizer,\\n dropout=dropout,\\n input_layer_partitioner=input_layer_partitioner,\\n config=config,\\n data_conf=data_conf)\",\n \"def create_mean_teacher_model(self) -> None:\\n self._mean_teacher_model = create_model_with_temperature_scaling(self.config)\",\n \"def config_task(self) -> None:\\n weights = self.hyperparams[\\\"weights\\\"]\\n\\n if self.hyperparams[\\\"model\\\"] == \\\"unet\\\":\\n self.model = smp.Unet(\\n encoder_name=self.hyperparams[\\\"backbone\\\"],\\n encoder_weights=\\\"imagenet\\\" if weights is True else None,\\n in_channels=self.hyperparams[\\\"in_channels\\\"],\\n classes=self.hyperparams[\\\"num_classes\\\"],\\n )\\n elif self.hyperparams[\\\"model\\\"] == \\\"deeplabv3+\\\":\\n self.model = smp.DeepLabV3Plus(\\n encoder_name=self.hyperparams[\\\"backbone\\\"],\\n encoder_weights=\\\"imagenet\\\" if weights is True else None,\\n in_channels=self.hyperparams[\\\"in_channels\\\"],\\n classes=self.hyperparams[\\\"num_classes\\\"],\\n )\\n elif self.hyperparams[\\\"model\\\"] == \\\"fcn\\\":\\n self.model = FCN(\\n in_channels=self.hyperparams[\\\"in_channels\\\"],\\n classes=self.hyperparams[\\\"num_classes\\\"],\\n num_filters=self.hyperparams[\\\"num_filters\\\"],\\n )\\n else:\\n raise ValueError(\\n f\\\"Model type '{self.hyperparams['model']}' is not valid. \\\"\\n f\\\"Currently, only supports 'unet', 'deeplabv3+' and 'fcn'.\\\"\\n )\\n\\n if self.hyperparams[\\\"loss\\\"] == \\\"ce\\\":\\n ignore_value = -1000 if self.ignore_index is None else self.ignore_index\\n\\n class_weights = None\\n if isinstance(self.class_weights, torch.Tensor):\\n class_weights = self.class_weights.to(dtype=torch.float32)\\n elif hasattr(self.class_weights, \\\"__array__\\\") or self.class_weights:\\n class_weights = torch.tensor(self.class_weights, dtype=torch.float32)\\n\\n self.loss = nn.CrossEntropyLoss(\\n ignore_index=ignore_value, weight=class_weights\\n )\\n elif self.hyperparams[\\\"loss\\\"] == \\\"jaccard\\\":\\n self.loss = smp.losses.JaccardLoss(\\n mode=\\\"multiclass\\\", classes=self.hyperparams[\\\"num_classes\\\"]\\n )\\n elif self.hyperparams[\\\"loss\\\"] == \\\"focal\\\":\\n self.loss = smp.losses.FocalLoss(\\n \\\"multiclass\\\", ignore_index=self.ignore_index, normalized=True\\n )\\n else:\\n raise ValueError(\\n f\\\"Loss type '{self.hyperparams['loss']}' is not valid. \\\"\\n f\\\"Currently, supports 'ce', 'jaccard' or 'focal' loss.\\\"\\n )\\n\\n if self.hyperparams[\\\"model\\\"] != \\\"fcn\\\":\\n if weights and weights is not True:\\n if isinstance(weights, WeightsEnum):\\n state_dict = weights.get_state_dict(progress=True)\\n elif os.path.exists(weights):\\n _, state_dict = utils.extract_backbone(weights)\\n else:\\n state_dict = get_weight(weights).get_state_dict(progress=True)\\n self.model.encoder.load_state_dict(state_dict)\\n\\n # Freeze backbone\\n if self.hyperparams.get(\\\"freeze_backbone\\\", False) and self.hyperparams[\\n \\\"model\\\"\\n ] in [\\\"unet\\\", \\\"deeplabv3+\\\"]:\\n for param in self.model.encoder.parameters():\\n param.requires_grad = False\\n\\n # Freeze decoder\\n if self.hyperparams.get(\\\"freeze_decoder\\\", False) and self.hyperparams[\\n \\\"model\\\"\\n ] in [\\\"unet\\\", \\\"deeplabv3+\\\"]:\\n for param in self.model.decoder.parameters():\\n param.requires_grad = False\",\n \"def set_up_and_parameterise_model_for_experiment(self):\\n self.experiment_unique_steps_to_model = {}\\n for op_number, op in enumerate(self.experiment.unique_steps):\\n new_model = self.model.new_copy()\\n new_parameter_values = self.parameter_values.copy()\\n\\n if op.type != \\\"current\\\":\\n # Voltage or power control\\n # Create a new model where the current density is now a variable\\n # To do so, we replace all instances of the current density in the\\n # model with a current density variable, which is obtained from the\\n # FunctionControl submodel\\n # check which kind of external circuit model we need (differential\\n # or algebraic)\\n if op.type == \\\"voltage\\\":\\n submodel_class = pybamm.external_circuit.VoltageFunctionControl\\n elif op.type == \\\"power\\\":\\n submodel_class = pybamm.external_circuit.PowerFunctionControl\\n\\n # Build the new submodel and update the model with it\\n submodel = submodel_class(new_model.param, new_model.options)\\n variables = new_model.variables\\n submodel.variables = submodel.get_fundamental_variables()\\n variables.update(submodel.variables)\\n submodel.variables.update(submodel.get_coupled_variables(variables))\\n variables.update(submodel.variables)\\n submodel.set_rhs(variables)\\n submodel.set_algebraic(variables)\\n submodel.set_initial_conditions(variables)\\n new_model.rhs.update(submodel.rhs)\\n new_model.algebraic.update(submodel.algebraic)\\n new_model.initial_conditions.update(submodel.initial_conditions)\\n\\n # Set the \\\"current function\\\" to be the variable defined in the submodel\\n new_parameter_values[\\\"Current function [A]\\\"] = submodel.variables[\\n \\\"Current [A]\\\"\\n ]\\n self.update_new_model_events(new_model, op)\\n # Update parameter values\\n self._original_temperature = new_parameter_values[\\\"Ambient temperature [K]\\\"]\\n experiment_parameter_values = self.get_experiment_parameter_values(\\n op, op_number\\n )\\n new_parameter_values.update(\\n experiment_parameter_values, check_already_exists=False\\n )\\n parameterised_model = new_parameter_values.process_model(\\n new_model, inplace=False\\n )\\n self.experiment_unique_steps_to_model[repr(op)] = parameterised_model\\n\\n # Set up rest model if experiment has start times\\n if self.experiment.initial_start_time:\\n new_model = self.model.new_copy()\\n # Update parameter values\\n new_parameter_values = self.parameter_values.copy()\\n self._original_temperature = new_parameter_values[\\\"Ambient temperature [K]\\\"]\\n new_parameter_values.update(\\n {\\\"Current function [A]\\\": 0, \\\"Ambient temperature [K]\\\": \\\"[input]\\\"},\\n check_already_exists=False,\\n )\\n parameterised_model = new_parameter_values.process_model(\\n new_model, inplace=False\\n )\\n self.experiment_unique_steps_to_model[\\n \\\"Rest for padding\\\"\\n ] = parameterised_model\",\n \"def evaluate_model(self, t, scaling_parameters, system_parameters):\\n raise NotImplementedError\",\n \"def prepare_model_(model, *data, device='cpu'):\\n _auto_name('', model)\\n set_default_parent(model)\\n def _prep_data(d):\\n if isinstance(d, (np.ndarray, torch.Tensor)):\\n return torch.as_tensor(d).to(device)\\n elif isinstance(d, (list, tuple)):\\n if all(isinstance(x, int) for x in d):\\n return torch.randn(*d, device=device)\\n return [_prep_data(x) for x in d]\\n elif isinstance(d, dict):\\n return {k:_prep_data(v) for k, v in d.items()}\\n with torch.no_grad():\\n is_training = model.training\\n data = [_prep_data(d) for d in data]\\n model.eval()\\n model.to(device)\\n model(*data)\\n model.train(is_training)\\n return model\",\n \"def build_model(self):\\n model = None\\n if self.model_name == 'vgg16':\\n model = vgg16(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels))\\n elif self.model_name == 'resnet':\\n model = ResNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\\n elif self.model_name == 'densenet':\\n model = DenseNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\\n elif self.model_name == 'mobilenet':\\n model = MobileNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\\n elif self.model_name == 'efficientnet':\\n model = efficientnet(input_shape=(self.ex_input_size, self.ex_input_size, self.ex_channels))\\n elif self.model_name == 'vit':\\n model = VisionTransformer(image_size=self.ex_input_size,\\n patch_size=vit_settings['patch_size'],\\n num_layers=vit_settings['num_layers'],\\n num_classes=num_classes,\\n d_model=vit_settings['d_model'],\\n num_heads=vit_settings['num_heads'],\\n mlp_dim=vit_settings['mlp_dim'],\\n channels=self.ex_channels,\\n dropout=vit_settings['dropout']).build_VisionTransformer()\\n model.load_weights(self.path_to_weights)\\n model.summary()\\n return model\",\n \"def _random_model(self, input_size, output_size, task, config: dict) -> AbstractModel:\\n return create_random_model(input_size, output_size, config, task)\",\n \"def build_cut_model(self):\\n model = None\\n if self.model_name == 'vgg16':\\n model = vgg16(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels))\\n elif self.model_name == 'resnet':\\n model = ResNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\\n elif self.model_name == 'densenet':\\n model = DenseNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\\n elif self.model_name == 'mobilenet':\\n model = MobileNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\\n elif self.model_name == 'efficientnet':\\n model = efficientnet(input_shape=(self.ex_input_size, self.ex_input_size, self.ex_channels))\\n elif self.model_name == 'vit':\\n model = VisionTransformer(image_size=self.ex_input_size,\\n patch_size=vit_settings['patch_size'],\\n num_layers=vit_settings['num_layers'],\\n num_classes=num_classes,\\n d_model=vit_settings['d_model'],\\n num_heads=vit_settings['num_heads'],\\n mlp_dim=vit_settings['mlp_dim'],\\n channels=self.ex_channels,\\n dropout=vit_settings['dropout']).build_VisionTransformer()\\n model.load_weights(self.path_to_weights)\\n model = Model(model.input, model.get_layer(self.ex_last_conv_layer_name2).output)\\n model.summary()\\n return model\",\n \"def create_model(model_class, model_params=None, model_name='model'):\\n\\n model_params = {} if model_params is None else model_params\\n\\n model = model_class(**model_params)\\n\\n if special_parameters.load_model: # recover from checkpoint\\n _load_model(model, model_name)\\n\\n # configure usage on GPU\\n if use_gpu():\\n model.to(first_device())\\n model = torch.nn.DataParallel(model, device_ids=all_devices())\\n\\n # print info about devices\\n print_info('Device(s)): ' + str(device_description()))\\n\\n return model\",\n \"def _adjust_for_gpus(cls, model: DeviceAwareModule, config: ModelConfigBase,\\n model_execution_mode: ModelExecutionMode) -> DeviceAwareModule:\\n if config.use_gpu:\\n model = model.cuda()\\n logging.info(\\\"Adjusting the model to use mixed precision training.\\\")\\n # If model parallel is set to True, then partition the network across all available gpus.\\n if config.use_model_parallel:\\n devices = config.get_cuda_devices()\\n assert devices is not None # for mypy\\n model.partition_model(devices=devices) # type: ignore\\n else:\\n logging.info(\\\"Making no adjustments to the model because no GPU was found.\\\")\\n\\n # Update model related config attributes (After Model Parallel Activated)\\n config.adjust_after_mixed_precision_and_parallel(model)\\n\\n # DataParallel enables running the model with multiple gpus by splitting samples across GPUs\\n # If the model is used in training mode, data parallel is activated by default.\\n # Similarly, if model parallel is not activated, data parallel is used as a backup option\\n use_data_parallel = (model_execution_mode == ModelExecutionMode.TRAIN) or (not config.use_model_parallel)\\n if config.use_gpu and use_data_parallel:\\n logging.info(\\\"Adjusting the model to use DataParallel\\\")\\n # Move all layers to the default GPU before activating data parallel.\\n # This needs to happen even though we put the model to the GPU at the beginning of the method,\\n # but we may have spread it across multiple GPUs later.\\n model = model.cuda()\\n model = DataParallelModel(model, device_ids=config.get_cuda_devices())\\n\\n return model\",\n \"def create_model():\\r\\n parser = argparse.ArgumentParser()\\r\\n parser.add_argument('--DISC_LR', type=float, default=1e-4)\\r\\n parser.add_argument('--GEN_LR', type=float, default=1e-3)\\r\\n parser.add_argument('--GEN_BETA1', type=float, default=0.9)\\r\\n parser.add_argument('--GEN_BETA2', type=float, default=0.999)\\r\\n parser.add_argument('--IMAGE_SIZE', type=int, default=None)\\r\\n parser.add_argument('--QUES_SIZE', type=int, default=None)\\r\\n parser.add_argument('--QUES_EMBED_SIZE', type=int, default=2048)\\r\\n parser.add_argument('--WORD_EMBED_SIZE', type=int, default=512)\\r\\n parser.add_argument('--VOCAB_SIZE', type=int, default=1004)\\r\\n args, task_args = parser.parse_known_args()\\r\\n override_if_not_in_args('--max_steps', '1000', task_args)\\r\\n override_if_not_in_args('--batch_size', '64', task_args)\\r\\n override_if_not_in_args('--eval_set_size', '370', task_args)\\r\\n override_if_not_in_args('--eval_interval_secs', '2', task_args)\\r\\n override_if_not_in_args('--log_interval_secs', '2', task_args)\\r\\n override_if_not_in_args('--min_train_eval_rate', '2', task_args)\\r\\n\\r\\n return Model(args.DISC_LR, args.GEN_LR, args.GEN_BETA1, args.GEN_BETA2,\\r\\n args.IMAGE_SIZE, args.QUES_EMBED_SIZE, args.WORD_EMBED_SIZE,\\r\\n args.QUES_SIZE, args.VOCAB_SIZE), task_args\",\n \"def model_setup(params):\\n n_classes = len(classes_config.training_ids)\\n if general_config.model_id == constants.ssdlite:\\n model = SSDLite.SSD_Head(n_classes=n_classes, k_list=anchor_config.k_list)\\n elif general_config.model_id == constants.ssd:\\n model = resnet_ssd.SSD300(n_classes=n_classes)\\n elif general_config.model_id == constants.ssd_modified:\\n model = SSDLite.SSD_Head(n_classes=n_classes, k_list=anchor_config.k_list,\\n out_channels=params.out_channels, width_mult=params.width_mult)\\n model.to(general_config.device)\\n\\n return model\",\n \"def make_model(self):\\n if self.model_type=='densenet_121':\\n model = self.make_densenet_121(self.weights)\\n\\n\\n return model\",\n \"def create_model(configuration):\\n model = find_model_using_name(configuration['model_name'])\\n instance = model(configuration)\\n print(\\\"model [{0}] was created\\\".format(type(instance).__name__))\\n return instance\",\n \"def build_model(cfg, model, gpu_id=None):\\n if torch.cuda.is_available():\\n assert (\\n cfg.NUM_GPUS <= torch.cuda.device_count()\\n ), \\\"Cannot use more GPU devices than available\\\"\\n else:\\n assert (\\n cfg.NUM_GPUS == 0\\n ), \\\"Cuda is not available. Please set `NUM_GPUS: 0 for running on CPUs.\\\"\\n\\n # Construct the model\\n # name = cfg.MODEL.MODEL_NAME\\n # model = MODEL_REGISTRY.get(name)(cfg)\\n \\n if cfg.NUM_GPUS:\\n if gpu_id is None:\\n # Determine the GPU used by the current process\\n cur_device = torch.cuda.current_device()\\n else:\\n cur_device = gpu_id\\n # Transfer the model to the current GPU device\\n model = model.cuda(device=cur_device)\\n # Use multi-process data parallel model in the multi-gpu setting\\n if cfg.NUM_GPUS > 1:\\n # Make model replica operate on the current device\\n #, find_unused_parameters=True\\n model = torch.nn.parallel.DistributedDataParallel(\\n module=model, device_ids=[cur_device], output_device=cur_device\\n )\\n \\n return model\",\n \"def _compute_single_model(self, **kwargs):\\n _, shape_parameter_settings = self._kwargs_to_settings(**kwargs)\\n config = combine_dicts(self.pdf_base_config, shape_parameter_settings, deep_copy=True)\\n\\n config['never_save_to_cache'] = True\\n return Model(config, **shape_parameter_settings)\",\n \"def __call__(self,setup_options=True, instantiate_options=True, verbose=False):\\n model = self.setup(setup_options)\\n model(instantiate_options, verbose)\\n return model\",\n \"def create_model(self, **inputs):\\n raise NotImplementedError('This method has to be overwritten.')\",\n \"def create_model(self, fun, kwargs=None, compile=True):\\n if kwargs is None:\\n kwargs = {}\\n\\n self.model = fun(self.config.inputs, self.config.output, **kwargs)\\n if compile:\\n self.model.compile(\\n loss=self.config.get_loss(self.modeldir),\\n optimizer=\\\"adam\\\", metrics=[\\\"accuracy\\\"])\",\n \"def _create_model(self):\\n if torch.cuda.is_available():\\n model = torch.jit.load(self.torch_jit).cuda()\\n else:\\n model = torch.jit.load(self.torch_jit)\\n model.eval()\\n return model\",\n \"def backend_specific_model(model: TModel, tmp_dir: str):\",\n \"def register_model(self, tags: Optional[Dict[str, str]] = None) -> Model:\\n if self.run is None:\\n raise ValueError(\\n \\\"An experiment has to be run before a model can be registered\\\"\\n )\\n self.model = self.run.register_model(\\n model_name=self.name,\\n model_path=\\\"outputs/model.pkl\\\",\\n properties=tags,\\n )\\n return self.model\",\n \"def __init__(self,\\n names,\\n data,\\n embedding_fns,\\n encoder_fns_1,\\n encoder_fns_2,\\n logits_fns,\\n evaluation_fns,\\n # MTL\\n mixing_ratios,\\n L2_coefficient=None,\\n is_distill=False,\\n distill_coefficient_loc=None,\\n distill_coefficient_scale=None,\\n distill_temperature=1.0,\\n # optimization\\n optimizer=\\\"Adam\\\",\\n learning_rate=0.001,\\n gradient_clipping_norm=2.0,\\n # misc\\n graph=None,\\n logdir=None,\\n main_model_index=0,\\n debug_mode=False):\\n \\n super(MultitaskBaseModel, self).__init__(\\n logdir=logdir, graph=graph,\\n saver_max_to_keep=MAX_CHECKPOINTS_TO_KEEP)\\n\\n num_models = len(names)\\n _check_list_compatability(data, num_models)\\n _check_fn_list_compatability(embedding_fns, num_models, True)\\n _check_fn_list_compatability(encoder_fns_1, num_models, True)\\n _check_fn_list_compatability(encoder_fns_2, num_models, True)\\n _check_fn_list_compatability(logits_fns, num_models, False)\\n _check_fn_list_compatability(evaluation_fns, num_models, False)\\n\\n # check mixing ratios and MTL\\n if len(names) == 1:\\n raise ValueError(\\\"Not supported\\\")\\n _mr_compatible(mixing_ratios, num_models, print_out=True)\\n if main_model_index != 0:\\n raise ValueError(\\\"`main_model_index` must be set to `0`\\\")\\n\\n self._names = names\\n self._data = data\\n self._embedding_fns = embedding_fns\\n self._encoder_fns_1 = encoder_fns_1\\n self._encoder_fns_2 = encoder_fns_2\\n self._logits_fns = logits_fns\\n self._evaluation_fns = evaluation_fns\\n\\n # MTL\\n self._mixing_ratios = mixing_ratios\\n self._L2_coefficient = L2_coefficient\\n self._is_disill = is_distill\\n self._distill_temperature = distill_temperature\\n self._distill_coefficient_loc = distill_coefficient_loc\\n self._distill_coefficient_scale = distill_coefficient_scale\\n\\n self._optimizer = optimizer\\n self._learning_rate = learning_rate\\n self._gradient_clipping_norm = gradient_clipping_norm\\n\\n self._main_model_index = main_model_index\\n self._debug = collections.defaultdict(list)\\n self._debug_mode = debug_mode\",\n \"def config_task(self) -> None:\\n if self.hparams[\\\"model\\\"] == \\\"resnet18\\\":\\n self.model = models.resnet18(pretrained=True)\\n in_features = self.model.fc.in_features\\n self.model.fc = nn.Linear( # type: ignore[attr-defined]\\n in_features, out_features=1\\n )\\n else:\\n raise ValueError(f\\\"Model type '{self.hparams['model']}' is not valid.\\\")\",\n \"def build_model(cfg, gpu_id=None):\\n # Construct the model\\n if MODEL_REGISTRY.get(cfg.MODEL.NAME) == None:\\n # attempt to find standard models\\n model = BaseVideoModel(cfg)\\n else:\\n # if the model is explicitly defined,\\n # it is directly constructed from the model pool\\n model = MODEL_REGISTRY.get(cfg.MODEL.NAME)(cfg)\\n\\n if torch.cuda.is_available():\\n assert (\\n cfg.NUM_GPUS <= torch.cuda.device_count()\\n ), \\\"Cannot use more GPU devices than available\\\"\\n else:\\n assert (\\n cfg.NUM_GPUS == 0\\n ), \\\"Cuda is not available. Please set `NUM_GPUS: 0 for running on CPUs.\\\"\\n\\n if cfg.NUM_GPUS:\\n if gpu_id is None:\\n # Determine the GPU used by the current process\\n cur_device = torch.cuda.current_device()\\n else:\\n cur_device = gpu_id\\n model = model.cuda(device=cur_device)\\n \\n model_ema = None\\n if cfg.MODEL.EMA.ENABLE:\\n model_ema = ModelEmaV2(model, decay=cfg.MODEL.EMA.DECAY)\\n\\n try:\\n # convert batchnorm to be synchronized across \\n # different GPUs if needed\\n sync_bn = cfg.BN.SYNC_BN\\n if sync_bn == True and cfg.NUM_GPUS * cfg.NUM_SHARDS > 1:\\n model = nn.SyncBatchNorm.convert_sync_batchnorm(model)\\n except:\\n sync_bn = None\\n\\n # Use multi-process data parallel model in the multi-gpu setting\\n if cfg.NUM_GPUS*cfg.NUM_SHARDS > 1:\\n # Make model replica operate on the current device\\n if cfg.PAI:\\n # Support distributed training on the cluster\\n model = torch.nn.parallel.DistributedDataParallel(\\n module=model\\n )\\n else:\\n model = torch.nn.parallel.DistributedDataParallel(\\n module=model, device_ids=[cur_device], output_device=cur_device\\n )\\n\\n return model, model_ema\",\n \"def create_model(ModelName=None, PrimaryContainer=None, Containers=None, ExecutionRoleArn=None, Tags=None, VpcConfig=None, EnableNetworkIsolation=None):\\n pass\",\n \"def create_and_copy_model(model, create_model_func, **kwargs):\\n new_model = create_model_func(**kwargs)\\n\\n update_model_weights( # copy trainable weights\\n new_model, model.trainable_weights,\\n weights_structure=get_model_weights_structure(new_model, trainable=True),\\n trainable=True, force_update=True)\\n\\n update_model_weights( # copy non-trainable weights\\n new_model, model.non_trainable_weights,\\n weights_structure=get_model_weights_structure(new_model, trainable=False),\\n trainable=False, force_update=True)\\n\\n # make sure that model is \\\"built\\\" and new variables are not created\\n build_model(new_model, model.input_shape)\\n\\n return new_model\",\n \"def from_pretrained(model_name: str, aliases: Dict = None, device: str = None):\\n if device == None:\\n device = \\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\"\\n\\n model = None\\n\\n models = AutoModel.list_models(return_dict=True)\\n model_config = models.get(model_name)\\n\\n # Try to find by alias\\n if model_config == None and aliases:\\n name_from_alias = aliases.get(model_name)\\n\\n if name_from_alias:\\n model_config = models.get(name_from_alias)\\n if model_config:\\n model_name = name_from_alias\\n\\n # Try to load from local saved model\\n if model_config == None:\\n try:\\n model = load(model_name)\\n model.to(device)\\n except ValueError:\\n raise ValueError(f\\\"Model '{model_name}' not found\\\")\\n \\n if model == None:\\n model_class = model_config[\\\"class\\\"]\\n init_kwargs = model_config[\\\"init_kwargs\\\"]\\n\\n model = model_config[\\\"class\\\"](**init_kwargs,\\n description=model_config[\\\"description\\\"],\\n tasks=model_config[\\\"tasks\\\"],\\n name=model_name,\\n details=model_config.get(\\\"details\\\"),\\n device=device)\\n\\n return model\",\n \"def prepare(cls, model, device, **kwargs):\\n super(SingaBackend, cls).prepare(model, device, **kwargs)\\n # when parsing graph, we use the shape of input gived by onnx to init a random value\\n # HOWEVER, the random value may not be correct for some inputs, such as gather which needs indices\\n # so if have operators, the user must give inputs\\n init_inputs = kwargs.get(\\\"init_inputs\\\", None)\\n # whether initializers are moved into inputs, due to https://github.com/onnx/onnx/issues/2417\\n # sometimes, input contains all initializer's info, sometimes, may not\\n cls.keep_initializers_as_inputs = kwargs.get(\\n 'keep_initializers_as_inputs', True)\\n # optimize and infer the shape of the model\\n try:\\n model = onnx.utils.polish_model(model)\\n except IndexError as err:\\n # due to https://github.com/onnx/onnx/issues/2417\\n model = onnx.shape_inference.infer_shapes(model)\\n\\n # check the opset version and ir version\\n opset_version = None\\n for imp in model.opset_import:\\n if not imp.HasField(\\\"domain\\\") or imp.domain == \\\"\\\":\\n opset_version = imp.version\\n if imp.version > cls._known_opset_version:\\n warnings.warn(\\n \\\"This version of singa targets ONNX operator set version {}, but the model we are trying to import uses version {}. We will try to import it anyway, but if the model uses operators which had BC-breaking changes in the intervening versions, import will fail.\\\"\\n .format(cls._known_opset_version, imp.version))\\n else:\\n warnings.warn(\\\"Unrecognized operator set {}\\\".format(imp.domain))\\n if opset_version is None:\\n if model.ir_version >= 0x00000003:\\n raise RuntimeError(\\n \\\"Model with IR version >= 3 did not specify ONNX operator set version (singa requires it)\\\"\\n )\\n else:\\n opset_version = 1\\n weights, singa_ops = cls._onnx_model_to_singa_net(\\n model, init_inputs, device, opset_version)\\n return SingaRep(model, weights, singa_ops,\\n cls.keep_initializers_as_inputs)\",\n \"def tff_model_fn():\\n keras_model = load_model(FLAGS.batch_size)\\n loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\\n return simple_fedavg_tf.KerasModelWrapper(keras_model,\\n test_data.element_spec, loss)\",\n \"def from_config(cls, *args, **kwargs):\\n _config = args\\n\\n if isinstance(args, tuple): # multiple non-keyword arguments were provided\\n if len(args) > 0:\\n _config = args[0]\\n\\n else:\\n _config = kwargs['config_path']\\n kwargs.pop('config_path')\\n\\n local = False\\n if 'make_new_path' in kwargs:\\n local = True\\n elif isinstance(_config, str) and os.path.isfile(_config):\\n local = True\\n elif isinstance(_config, dict) and \\\"category\\\" in _config:\\n local = True\\n\\n if local:\\n config = None\\n config_path = None\\n\\n # we need to build ai4water's Model class\\n if isinstance(_config, dict):\\n config = _config\\n else:\\n config_path = _config\\n return BaseModel._get_config_and_path(\\n cls,\\n config=config,\\n config_path=config_path,\\n **kwargs\\n )\\n\\n # tf1.15 has from_config so call it\\n return super().from_config(*args, **kwargs)\",\n \"def initialize_multitask_model(\\n *,\\n model_def: nn.Module,\\n input_spec: Dict[Tuple[Tuple[str, str], ...],\\n Sequence[Union[Tuple[Tuple[int, ...], jnp.dtype],\\n Tuple[int, ...]]]],\\n config: ml_collections.ConfigDict,\\n rngs: Union[jnp.ndarray, Mapping[str, jnp.ndarray]],\\n) -> Tuple[PyTree, PyTree, int, Optional[Dict[str, float]]]:\\n\\n def init_fn(model_def):\\n for kwargs, in_spec in input_spec.items():\\n\\n if config.get('batch_sizes') is not None:\\n batch_size = config.batch_sizes.get(dict(kwargs)['dataset'])\\n else:\\n batch_size = config.batch_size\\n\\n batch_size = (batch_size // jax.device_count()) if batch_size else None\\n\\n input_shapetype = [\\n debug_utils.input_spec_to_jax_shape_dtype_struct(\\n spec, batch_size=batch_size) for spec in in_spec\\n ]\\n dummy_input = []\\n for in_st in input_shapetype:\\n dummy_input.append(jnp.zeros(in_st.shape, in_st.dtype))\\n model_def(\\n *dummy_input, train=False, debug=False, **dict(kwargs))\\n\\n # We want all parameters to be created in host RAM, not on any device, they'll\\n # be sent there later as needed, otherwise we already encountered two\\n # situations where we allocate them twice.\\n @functools.partial(jax.jit, backend='cpu')\\n def _initialize_model(rngs):\\n \\\"\\\"\\\"Initialization function to be jitted.\\\"\\\"\\\"\\n init_model_state, init_params = nn.init(\\n fn=init_fn, module=model_def)(rngs).pop('params')\\n # Set bias in the head to low value, such that loss is small initially.\\n if (config.get('init_head_bias', None) is not None and\\n 'output_projection' in init_params):\\n init_params = flax.core.unfreeze(init_params)\\n init_params['output_projection'] = optimizers.tree_map_with_names(\\n lambda p: jnp.full_like(p, config.init_head_bias),\\n init_params['output_projection'],\\n match_name_fn=lambda name: 'bias' in name)\\n init_params = flax.core.freeze(init_params)\\n return init_params, init_model_state\\n\\n if not isinstance(rngs, dict):\\n rngs = {'params': rngs}\\n init_params, init_model_state = _initialize_model(rngs)\\n # Pop out params rng:\\n rngs.pop('params')\\n\\n # Count number of trainable parameters:\\n num_trainable_params = debug_utils.log_param_shapes(init_params)\\n\\n # Count gflops:\\n count_flops = config.get('count_flops',\\n ml_collections.ConfigDict({'count_flops': True}))\\n if count_flops:\\n variables = {'params': init_params, **init_model_state}\\n gflops_dict = {}\\n gflops_all = 0\\n for kwargs, in_spec in input_spec.items():\\n flops = debug_utils.compute_flops(\\n flax_model_apply_fn=functools.partial(\\n model_def.apply,\\n variables,\\n train=False,\\n debug=False,\\n rngs=rngs,\\n **dict(kwargs)),\\n input_spec=count_flops.get('input_spec', in_spec),\\n fuse_multiply_add=count_flops.get('fuse_multiply_add', True))\\n gflops = flops / (10**9)\\n gflops_key = 'gflops/' + '/'.join(f'{x}={y}' for x, y in kwargs)\\n gflops_dict[gflops_key] = gflops\\n gflops_all += gflops\\n gflops_dict['gflops'] = gflops_all\\n else:\\n gflops_dict = None\\n\\n return init_params, init_model_state, num_trainable_params, gflops_dict\",\n \"def construct_model(self, output_model_path):\\n\\n input_tensor = helper.make_tensor_value_info(\\\"input\\\", TensorProto.FLOAT, [1, 1, 7, 7])\\n output_tensor = helper.make_tensor_value_info(\\\"output\\\", TensorProto.FLOAT, [1, 1, 8, 8])\\n ini_w = helper.make_tensor(\\\"weight\\\", TensorProto.FLOAT, [1, 1, 2, 2], [1.0, 1.0, 1.0, 1.0])\\n ini_b = helper.make_tensor(\\\"bias\\\", TensorProto.FLOAT, [1], [0.17])\\n conv_tranpose_node = onnx.helper.make_node(\\n \\\"ConvTranspose\\\",\\n [\\\"input\\\", \\\"weight\\\", \\\"bias\\\"],\\n [\\\"output\\\"],\\n kernel_shape=[2, 2],\\n output_padding=[0, 0],\\n pads=[0, 0, 0, 0],\\n strides=[1, 1],\\n dilations=[1, 1],\\n group=1,\\n )\\n graph = helper.make_graph(\\n [conv_tranpose_node],\\n \\\"conv_transpose_test\\\",\\n [input_tensor],\\n [output_tensor],\\n initializer=[ini_w, ini_b],\\n )\\n model = helper.make_model(graph, opset_imports=[helper.make_opsetid(\\\"\\\", 13)])\\n model.ir_version = 7 # use stable onnx ir version\\n\\n onnx.save(model, output_model_path)\",\n \"def build_model(model_name: Text,\\n model_config: archs.MobileNetConfig,\\n dataset_config: Optional[dataset_factory.DatasetConfig] = None,\\n ) -> tf.keras.models.Model:\\n\\n model_build_function = _get_model_builder().get(model_name)\\n if model_build_function:\\n if dataset_config:\\n image_size = dataset_config.image_size\\n channels = dataset_config.num_channels\\n model_config.input_shape = (image_size, image_size, channels)\\n model_config.num_classes = dataset_config.num_classes\\n return model_build_function(config=model_config)\\n else:\\n raise ValueError('The model {} is not supported.'.format(model_name))\",\n \"def create_model(self):\\n model = solph.Model(self.es)\\n return model\",\n \"def __init__(self, data_set, model, config):\\n\\n self.config = config\\n self.data_set = data_set\\n # Normalize or standardize the features, to have them ready to use as model input\\n self.data_set.shift_and_scale(self.config[\\\"shift\\\"], self.config[\\\"scaling\\\"])\\n self.model = model\\n self.model.eval()\\n self.device = torch.device(\\\"cpu\\\") if not self.config[\\\"use_gpu\\\"] \\\\\\n else torch.device(\\\"cuda:\\\" + str(self.config[\\\"gpu_no\\\"]))\",\n \"def config_from_pytorch_model(\\n model,\\n granularity='model',\\n backend=None,\\n default_precision='ap_fixed<16,6>',\\n default_reuse_factor=1,\\n inputs_channel_last=False,\\n transpose_outputs=True,\\n):\\n\\n config = {}\\n\\n model_config = {}\\n model_config['Precision'] = default_precision\\n model_config['ReuseFactor'] = default_reuse_factor\\n model_config['InputsChannelLast'] = inputs_channel_last\\n model_config['TransposeOutputs'] = transpose_outputs\\n model_config['Strategy'] = 'Latency'\\n\\n config['Model'] = model_config\\n\\n return config\",\n \"def train_model(self) -> Model:\\n run = self.submit_experiment_run(wait_for_completion=self.wait_for_completion)\\n model = run.register_model(\\n model_name=self.model_name, model_path=self.model_path\\n )\\n return model\",\n \"def model_fn_builder(config: electra_files.configure_finetuning.FinetuningConfig, tasks,\\n num_train_steps, pretraining_config=None):\\n\\n def model_fn(features, labels, mode, params):\\n \\\"\\\"\\\"The `model_fn` for TPUEstimator.\\\"\\\"\\\"\\n utils.log(\\\"Building model...\\\")\\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\\n model = FinetuningModel(\\n config, tasks, is_training, features, num_train_steps)\\n\\n if pretraining_config is not None:\\n # init_checkpoint = tf.train.latest_checkpoint(pretraining_config.model_dir)\\n init_checkpoint = pretraining_config['checkpoint']\\n utils.log(\\\"Using checkpoint\\\", init_checkpoint)\\n tvars = tf.trainable_variables()\\n scaffold_fn = None\\n if init_checkpoint:\\n assignment_map, _ = modeling.get_assignment_map_from_checkpoint(\\n tvars, init_checkpoint)\\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n\\n # Build model for training or prediction\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n train_op = optimization.create_optimizer(\\n model.loss, config.learning_rate, num_train_steps,\\n weight_decay_rate=config.weight_decay_rate,\\n use_tpu=config.use_tpu,\\n warmup_proportion=config.warmup_proportion,\\n layerwise_lr_decay_power=config.layerwise_lr_decay,\\n n_transformer_layers=model.bert_config.num_hidden_layers\\n )\\n output_spec = tf.estimator.tpu.TPUEstimatorSpec(\\n mode=mode,\\n loss=model.loss,\\n train_op=train_op,\\n scaffold_fn=scaffold_fn,\\n training_hooks=[training_utils.ETAHook(\\n {} if config.use_tpu else dict(loss=model.loss),\\n num_train_steps, config.iterations_per_loop, config.use_tpu, 10)])\\n else:\\n assert mode == tf.estimator.ModeKeys.PREDICT\\n output_spec = tf.estimator.tpu.TPUEstimatorSpec(\\n mode=mode,\\n predictions=utils.flatten_dict(model.outputs),\\n scaffold_fn=scaffold_fn)\\n\\n utils.log(\\\"Building complete\\\")\\n return output_spec\\n\\n return model_fn\",\n \"def get_model_adapter(config):\\n if config['task'] == 'joint':\\n return JointModelAdapter()\\n elif config['task'] == 'keypoints':\\n return KeypointsModelAdapter()\\n elif config['task'] == 'headsegmentation':\\n return HeadSegmentationModelAdapter()\\n elif config['task'] == 'detect':\\n return DetectionModelAdapter(config['model'])\\n return ClassificationModelAdapter()\",\n \"def eval_model(config):\\n print 'Model directory: %s' % config.model_output\\n print 'Running model: %s' % config.model_type\\n if config.model_type == 'fully_connected_mlp':\\n from models.fully_connected_mlp import model_struct\\n elif config.model_type == 'fully_connected_mlp_2l':\\n from models.fully_connected_mlp_2l import model_struct\\n elif config.model_type == 'fully_connected_conv':\\n from models.fully_connected_conv import model_struct\\n elif config.model_type == 'vgg_feature_model':\\n from models.vgg_feature_model import model_struct\\n else:\\n raise Exception\\n\\n # Prepare model training\\n dt_stamp = re.split(\\n '\\\\.', str(datetime.now()))[0].\\\\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\\n dt_dataset = config.model_type + '_' + dt_stamp + '/'\\n config.train_checkpoint = os.path.join(\\n config.model_output, dt_dataset) # timestamp this run\\n config.summary_dir = os.path.join(\\n config.train_summaries, config.model_output, dt_dataset)\\n dir_list = [config.train_checkpoint, config.summary_dir]\\n [make_dir(d) for d in dir_list]\\n\\n # Prepare model inputs\\n train_data = os.path.join(config.tfrecord_dir, 'train.tfrecords')\\n validation_data = os.path.join(config.tfrecord_dir, 'val.tfrecords')\\n feat_mean = 0 # np.mean(np.load(config.mean_file)['feat_list'])\\n\\n # Prepare data on CPU\\n with tf.device('/cpu:0'):\\n train_images, train_labels = inputs(\\n tfrecord_file=train_data,\\n batch_size=config.train_batch,\\n num_feats=config.n_features,\\n sample=config.sample['train'],\\n max_pixels_per_image=config.max_pixels_per_image,\\n im_size=config.resize,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n num_epochs=config.epochs,\\n feat_mean_value=feat_mean)\\n val_images, val_labels = inputs(\\n tfrecord_file=validation_data,\\n batch_size=1,\\n num_feats=config.n_features,\\n sample=config.sample['val'],\\n max_pixels_per_image=config.max_pixels_per_image,\\n im_size=config.resize,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n num_epochs=config.epochs,\\n feat_mean_value=feat_mean)\\n tf.summary.image('validation images', tf.cast(val_labels, tf.float32))\\n\\n # Prepare model on GPU\\n with tf.device('/gpu:0'):\\n with tf.variable_scope('cnn') as scope:\\n\\n model = model_struct()\\n train_mode = tf.get_variable(name='training', initializer=True)\\n model.build(\\n features=train_images,\\n output_categories=len(config.labels.keys()),\\n train_mode=train_mode, batchnorm=config.batch_norm)\\n\\n # Prepare the cost function\\n cost = softmax_cost(\\n model.res_logits, train_labels, ratio=config.ratio,\\n label_reshape=[\\n config.batch_size * config.max_pixels_per_image])\\n train_op = tf.train.AdamOptimizer(config.lr).minimize(cost)\\n\\n tf.summary.scalar(\\\"cost\\\", cost)\\n\\n train_score = correlation(\\n model.prob, train_labels) # training accuracy\\n tf.summary.scalar(\\\"training correlation\\\", train_score)\\n\\n # Setup validation op\\n if validation_data is not False:\\n scope.reuse_variables()\\n # Validation graph is the same as training except no batchnorm\\n val_model = model_struct()\\n val_model.build(\\n features=val_images,\\n output_categories=len(config.labels.keys()))\\n\\n # Calculate validation accuracy\\n val_pred = tf.cast(\\n tf.reshape(\\n tf.argmax(\\n val_model.prob, axis=1),\\n [1, config.resize[0], config.resize[1], 1]),\\n tf.float32)\\n tf.summary.image('validation prediction', val_pred)\\n val_score = correlation(\\n val_model.prob, tf.reshape(\\n val_labels, [np.prod(config.resize), 1]))\\n tf.summary.scalar(\\\"validation correlation\\\", val_score)\\n\\n # Set up summaries and saver\\n saver = tf.train.Saver(\\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\\n summary_op = tf.summary.merge_all()\\n\\n # Initialize the graph\\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\\n\\n # Need to initialize both of these if supplying num_epochs to inputs\\n sess.run(tf.group(tf.global_variables_initializer(),\\n tf.local_variables_initializer()))\\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\\n\\n # Set up exemplar threading\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\\n\\n # Start training loop\\n np.save(config.train_checkpoint, config)\\n step, val_max, losses = 0, 0, []\\n train_acc = 0\\n try:\\n while not coord.should_stop():\\n start_time = time.time()\\n _, loss_value, train_acc = sess.run([train_op, cost, train_score])\\n losses.append(loss_value)\\n duration = time.time() - start_time\\n assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\\n\\n if step % 100 == 0 and step % 10 == 0:\\n if validation_data is not False:\\n _, val_acc, val_frame = sess.run(\\n [train_op, val_score, val_pred])\\n\\n np.save(\\n os.path.join(\\n config.model_output, '%s_val_image' % step),\\n val_frame)\\n else:\\n val_acc = -1 # Store every checkpoint\\n\\n # Summaries\\n summary_str = sess.run(summary_op)\\n summary_writer.add_summary(summary_str, step)\\n\\n # Training status and validation accuracy\\n format_str = (\\n '%s: step %d, loss = %.2f (%.1f examples/sec; '\\n '%.3f sec/batch) | Training r = %s | '\\n 'Validation r = %s | logdir = %s')\\n print (format_str % (\\n datetime.now(), step, loss_value,\\n config.train_batch / duration, float(duration),\\n train_acc, val_acc, config.summary_dir))\\n\\n # Save the model checkpoint if it's the best yet\\n if val_acc > val_max:\\n saver.save(\\n sess, os.path.join(\\n config.train_checkpoint,\\n 'model_' + str(step) + '.ckpt'), global_step=step)\\n\\n # Store the new max validation accuracy\\n val_max = val_acc\\n\\n else:\\n # Training status\\n format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; '\\n '%.3f sec/batch) | Training F = %s')\\n print (format_str % (datetime.now(), step, loss_value,\\n config.train_batch / duration,\\n float(duration), train_acc))\\n # End iteration\\n step += 1\\n\\n except tf.errors.OutOfRangeError:\\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\\n finally:\\n coord.request_stop()\\n\\n dt_stamp = get_dt() # date-time stamp\\n np.save(\\n os.path.join(\\n config.tfrecord_dir, '%straining_loss' % dt_stamp), losses)\\n coord.join(threads)\\n sess.close()\",\n \"def make_model(cls, model_id: str):\\n try:\\n make_model = getattr(importlib.import_module(\\\"kgcnn.literature.%s\\\" % model_id), \\\"make_model\\\")\\n\\n except ModuleNotFoundError:\\n raise NotImplementedError(\\\"ERROR:kgcnn: Unknown model identifier %s\\\" % model_id)\\n\\n return make_model\",\n \"def createNewModel(self, modelName):\\n try:\\n storage = FileSystemStorage(join(settings.MEDIA_ROOT, 'models'))\\n\\n folderSufix = 1\\n new_model_name = modelName\\n while storage.exists(join(storage.base_location, new_model_name)):\\n folderSufix += 1\\n new_model_name = f'{modelName}_{folderSufix}'\\n\\n folder_path = join(storage.base_location, new_model_name)\\n model_file = join(folder_path, f'{new_model_name}.ppl')\\n\\n if not storage.exists(folder_path):\\n os.mkdir(folder_path)\\n\\n calcEngine = CalcEngine.factory(self.client_session)\\n if calcEngine.createNewModel(model_file, new_model_name):\\n self.closeModel()\\n return self.openModel(join(storage.base_location, new_model_name, f'{new_model_name}.ppl'))\\n except Exception as ex:\\n raise ex\",\n \"def build_variational_keras_model(\\n input_shape=[1],\\n layer_units=[200, 100, 1],\\n layer_activations=[\\\"relu\\\", \\\"relu\\\", \\\"linear\\\"],\\n initial_unconstrained_scale=None,\\n transform_unconstrained_scale_factor=0.05,\\n normalization_layer=False,\\n prior_scale_identity_multiplier=1,\\n kl_weight=None,\\n noise_scale_prior=None,\\n n_train=None,\\n mean_init_noise_scale=0.0,\\n names=None,\\n evaluate_ignore_prior_loss=True,\\n):\\n if names is None:\\n names = [None] * len(layer_units)\\n\\n # model = tf.keras.Sequential()\\n input = tf.keras.Input(shape=input_shape)\\n if normalization_layer:\\n x = NormalizationFix(input_shape=input_shape, name=\\\"normalization\\\")(input)\\n\\n prior = prior_fn_factory(prior_scale_identity_multiplier)\\n posterior_mean_field = posterior_mean_field_generator(mean_init_noise_scale)\\n for i, units, activation, name in zip(\\n range(len(layer_units)), layer_units, layer_activations, names\\n ):\\n layer = tfp.layers.DenseVariational(\\n units,\\n activation=activation,\\n name=name,\\n make_posterior_fn=posterior_mean_field,\\n make_prior_fn=prior,\\n kl_weight=kl_weight,\\n use_bias=True,\\n )\\n if i == 0 and not normalization_layer:\\n x = layer(input)\\n else:\\n x = layer(x)\\n if initial_unconstrained_scale is not None:\\n x = AddSigmaLayer(initial_unconstrained_scale, name=\\\"sigma_layer\\\")(x)\\n x = tfp.layers.DistributionLambda(\\n lambda t: tfd.Normal(\\n loc=t[..., :1],\\n scale=transform_unconstrained_scale(\\n t[..., 1:], transform_unconstrained_scale_factor\\n ),\\n )\\n )(x)\\n if evaluate_ignore_prior_loss:\\n model = ValidationModel(inputs=input, outputs=x)\\n else:\\n model = tf.keras.Model(inputs=input, outputs=x)\\n if initial_unconstrained_scale is not None:\\n if noise_scale_prior is not None:\\n model.add_loss(\\n lambda: -tf.reduce_sum(\\n noise_scale_prior.log_prob(\\n transform_unconstrained_scale(\\n model.get_layer(\\\"sigma_layer\\\").sigma,\\n transform_unconstrained_scale_factor,\\n )\\n )\\n )\\n / n_train\\n )\\n return model\",\n \"def create_model(self, setting: SettingType) -> BaselineModel[SettingType]:\\n # Create the model, passing the setting, hparams and config.\\n return MyCustomModel(setting=setting, hparams=self.hparams, config=self.config)\",\n \"def create_model(feats2d, shapes, model_settings, model_architecture,\\n is_training, runtime_settings=None):\\n if model_architecture == 'single_fc':\\n return create_single_fc_model(feats2d, shapes, model_settings, is_training)\\n elif model_architecture == 'simple_conv2D':\\n return create_simple_conv2D_model(feats2d, shapes, model_settings, is_training)\\n elif model_architecture == 'simple_conv1D':\\n return create_simple_conv1D_model(feats2d, shapes, model_settings, is_training)\\n elif model_architecture == 'lstm':\\n return create_bidirectionnal_dynamic_rnn_model(feats2d, shapes, model_settings, is_training)\\n elif model_architecture == 'cnn_lstm':\\n return create_CNN_LSTM_model(feats2d, shapes, model_settings, is_training)\\n elif model_architecture == 'dcnn_lstm':\\n return create_DCNN_LSTM_model(feats2d, shapes, model_settings, is_training)\\n else:\\n raise Exception('model_architecture argument \\\"' + model_architecture +\\n '\\\" not recognized, should be one of \\\"single_fc\\\", \\\"simple_conv2D\\\",' +\\n ' \\\"simple_conv1D\\\", or \\\"lstm\\\"')\",\n \"def build_model(\\n model_purpose: str,\\n name: str,\\n init_w: str,\\n input_shape: np.ndarray,\\n classes: int,\\n dropout_rate: np.float32,\\n) -> keras.Model:\\n\\n if model_purpose.startswith(\\\"segmentation\\\"):\\n seg_builder = sm.Seg_model_builder(name, input_shape, classes, dropout_rate)\\n model = seg_builder.get_model()\\n\\n elif model_purpose == \\\"inversion\\\":\\n reg_builder = rm.Reg_model_builder(name, input_shape, classes, init_w)\\n model = reg_builder.get_model()\\n\\n elif model_purpose == \\\"pixel_concentration_retrieval\\\":\\n model = pwrm.Unet_2(input_shape, classes)\\n\\n return model\",\n \"def _create_model(self):\\n ref = 0 if self.m_cfg['configs']['recursive'] else -1\\n out_t, l_t, models = [], [], []\\n in_t = [tf.keras.Input(batch_size=self.m_cfg['configs']['batch'],\\n shape=self.m_cfg['configs']['patch'])]\\n for level in np.arange(self.levels):\\n if not self.m_cfg['configs']['recursive'] or not level:\\n lat, res, layers = self._set_level_ops(in_t[-1], level)\\n opt = self._inst_optimizer()\\n self.opt += [opt]\\n curr_layers = sum(layers, [])\\n vars = sum(list(map(lambda l: l.variables, curr_layers)), [])\\n self.vars.append(vars)\\n elif self.m_cfg['configs']['recursive']:\\n lat, res, layers = self._set_level_ops(in_t[-1], level, layers)\\n\\n out_t += [res]\\n l_t += [lat]\\n in_t += [tf.keras.layers.Subtract()([in_t[ref], out_t[-1]])]\\n\\n inputs, outputs = in_t[0], [in_t[:-1], l_t, out_t]\\n self.model = tf.keras.Model(inputs=inputs, outputs=outputs)\\n self.loss = Losses(self.m_cfg['configs']['loss']).value\",\n \"def _InstantiateTaskModel(\\n self, task_params\\n ) -> Union[base_model.SingleTaskModel, base_model.MultiTaskModel]:\\n if issubclass(task_params.cls, base_model.MultiTaskSubModel):\\n return task_params.Instantiate(\\n shared_model=self._shared_model, executor_ema=self._executor_ema)\\n return task_params.Instantiate(executor_ema=self._executor_ema)\",\n \"def buildModel(model_name):\\n if model_name == \\\"resnet50\\\":\\n model = kapp.resnet50.ResNet50(weights=\\\"imagenet\\\", include_top=False)\\n return model, kapp.resnet50.preprocess_input\\n elif model_name == \\\"vgg16\\\":\\n model = kapp.vgg16.VGG16(weights=\\\"imagenet\\\", include_top=False)\\n return model, kapp.vgg16.preprocess_input\\n elif model_name == 'xception':\\n model = kapp.xception.Xception(weights=\\\"imagenet\\\", include_top=False)\\n return model, kapp.xception.preprocess_input\\n elif model_name == 'vgg19':\\n model = kapp.vgg19.VGG19(weights=\\\"imagenet\\\", include_top=False)\\n return model, kapp.vgg19.preprocess_input\\n elif model_name == 'inceptionv3':\\n model = kapp.inception_v3.InceptionV3(weights=\\\"imagenet\\\", include_top=False)\\n return model, kapp.inception_v3.preprocess_input\\n elif model_name == 'mobilenet':\\n model = kapp.mobilenet.MobileNet(weights=\\\"imagenet\\\", include_top=False)\\n return model, kapp.mobilenet.preprocess_input\\n else:\\n raise Exception(\\\"Unsupported model error\\\")\",\n \"def create(self, task_model):\\n raise NotImplementedError()\",\n \"def setup_model(self,\\n model_weights_path: Optional[str] = None,\\n model_def_path: Optional[str] = None) -> None:\\n if self.model is not None:\\n self.model.to(self.device)\\n return\\n\\n self._onnx_mode = (model_weights_path is not None\\n and model_weights_path.lower().endswith('.onnx'))\\n if self._onnx_mode:\\n model = self.load_onnx_model(model_weights_path)\\n else:\\n model = self.build_model(model_def_path)\\n\\n if self.cfg.model.external_def is not None:\\n # this model will have 1 extra output classes that we will ignore\\n self.model = TorchVisionODAdapter(model, ignored_output_inds=[0])\\n else:\\n # this model will have 2 extra output classes that we will ignore\\n num_classes = self.cfg.data.num_classes\\n self.model = TorchVisionODAdapter(\\n model, ignored_output_inds=[0, num_classes + 1])\\n\\n if not self._onnx_mode:\\n self.model.to(self.device)\\n self.load_init_weights(model_weights_path)\",\n \"def __init__(self,\\n model_fn=None,\\n model_dir=None,\\n config=None,\\n params=None,\\n use_tpu=True,\\n train_batch_size=None,\\n eval_batch_size=None,\\n predict_batch_size=None,\\n batch_axis=None):\\n if config is None or not isinstance(config, tpu_config.RunConfig):\\n raise ValueError(\\n '`config` must be provided with type `tpu_config.RunConfig`')\\n\\n if params is not None and any(k in params for k in _RESERVED_PARAMS_KEYS):\\n raise ValueError('{} are reserved keys but existed in params {}.'.format(\\n _RESERVED_PARAMS_KEYS, params))\\n\\n if use_tpu:\\n # Perform some very basic validations. More validations will be found in\\n # _TPUContext.\\n if train_batch_size is None:\\n raise ValueError('`train_batch_size` cannot be `None`')\\n util_lib.check_positive_integer(train_batch_size, 'train_batch_size')\\n\\n if (config.tpu_config.per_host_input_for_training is\\n tpu_config.InputPipelineConfig.PER_SHARD_V1 and\\n config.tpu_config.computation_shape):\\n raise ValueError(\\n 'Model parallelism only supports per host input for training. '\\n 'Please adjust TPURunconfig.per_host_input_for_training.')\\n\\n if eval_batch_size is not None:\\n util_lib.check_positive_integer(eval_batch_size, 'eval_batch_size')\\n\\n if predict_batch_size is not None:\\n util_lib.check_positive_integer(predict_batch_size,\\n 'predict_batch_size')\\n\\n # Verifies the model_fn signature according to Estimator framework.\\n estimator_lib._verify_model_fn_args(model_fn, params) # pylint: disable=protected-access\\n # We cannot store config and params in this constructor as parent\\n # constructor might change them, such as assigning a temp dir for\\n # config.model_dir.\\n model_function = self._augment_model_fn(model_fn, batch_axis)\\n\\n # Passing non-None params as wrapped model_fn has it.\\n params = params or {}\\n super(TPUEstimator, self).__init__(\\n model_fn=model_function,\\n model_dir=model_dir,\\n config=config,\\n params=params)\\n self._iterations_per_training_loop = (\\n self._config.tpu_config.iterations_per_loop)\\n\\n # All properties passed to _TPUContext are immutable.\\n # pylint: disable=protected-access\\n self._ctx = tpu_context._get_tpu_context(\\n self._config, train_batch_size,\\n eval_batch_size, predict_batch_size,\\n use_tpu)\\n\\n self._is_input_fn_invoked = None\",\n \"def set_up_model(dt, model, update = False):\\n \\n start_scope()\\n \\n ##### Update model parameters (should be done, if original parameters have been changed)\\n if update:\\n ###### Temperature in Kelvin\\n model.T_kelvin = model.zero_celsius + model.T_celsius*kelvin\\n \\n ##### Potentials\\n # Resting potential (calculated with Goldman equation)\\n model.V_res = (model.R*model.T_kelvin)/model.F * np.log((model.P_K*model.n_init**2*model.K_e + model.P_Na*model.h_init*model.m_init**3*model.Na_e)/\\\\\\n (model.P_K*model.n_init**2*model.K_i + model.P_Na*model.h_init*model.m_init**3*model.Na_i))\\n \\n # Nerst potential for leakage current; leakage chanels were excluded but could be added by using: g_L*(E_L-(v-V_res)) \\n model.E_L = (-1/model.g_L)*(model.P_Na*model.m_init**3*model.h_init*(model.V_res*model.F**2)/(model.R*model.T_kelvin) * \\\\\\n (model.Na_e-model.Na_i*exp(model.V_res*model.F/(model.R*model.T_kelvin)))/(1-np.exp(model.V_res*model.F/(model.R*model.T_kelvin))) + \\\\\\n model.P_K*model.n_init**2*(model.V_res*model.F**2)/(model.R*model.T_kelvin) *\\\\\\n (model.K_e-model.K_i*np.exp(model.V_res*model.F/(model.R*model.T_kelvin)))/(1-np.exp(model.V_res*model.F/(model.R*model.T_kelvin))))\\n \\n \\n ##### structure of ANF\\n # terminal = 0\\n # internode = 1\\n # node = 2\\n # presomatic region = 3\\n # Soma = 4\\n # postsomatic region = 5)\\n model.structure = np.array(list(np.tile([2,1],model.nof_internodes)) + [2])\\n model.nof_comps = len(model.structure)\\n \\n ##### Compartment lengths\\n # initialize\\n model.compartment_lengths = np.zeros_like(model.structure)*um\\n # length internodes\\n model.compartment_lengths[model.structure == 1] = model.length_internodes\\n # length nodes\\n model.compartment_lengths[model.structure == 2] = model.length_nodes\\n # total length neuron\\n model.length_neuron = sum(model.compartment_lengths)\\n \\n ##### Compartment diameters\\n # initialize\\n model.compartment_diameters = np.zeros(model.nof_comps+1)*um\\n # dendrite\\n model.fiber_inner_diameter = 0.7* model.fiber_outer_diameter\\n model.compartment_diameters[:] = model.fiber_inner_diameter\\n \\n ##### Compartment middle point distances (needed for plots)\\n model.distance_comps_middle = np.zeros_like(model.compartment_lengths)\\n model.distance_comps_middle[0] = 0.5*model.compartment_lengths[0]\\n for ii in range(0,model.nof_comps-1):\\n model.distance_comps_middle[ii+1] = 0.5* model.compartment_lengths[ii] + 0.5* model.compartment_lengths[ii+1]\\n \\n ##### Capacitivites\\n # initialize\\n model.c_m = np.zeros_like(model.structure)*uF/cm**2\\n # internodes\\n model.c_m[np.where(model.structure == 1)] = 0*uF/cm**2\\n # nodes\\n model.c_m[np.where(model.structure == 2)] = model.c_m_layer\\n \\n ##### Axoplasmatic resistances\\n model.compartment_center_diameters = np.zeros(model.nof_comps)*um\\n model.compartment_center_diameters = (model.compartment_diameters[0:-1] + model.compartment_diameters[1:]) / 2 \\n model.R_a = (model.compartment_lengths*model.rho_in) / ((model.compartment_center_diameters*0.5)**2*np.pi)\\n \\n ##### Surface arias\\n # lateral surfaces\\n m = [np.sqrt(abs(model.compartment_diameters[i+1] - model.compartment_diameters[i])**2 + model.compartment_lengths[i]**2)\\n for i in range(0,model.nof_comps)]\\n # total surfaces\\n model.A_surface = [(model.compartment_diameters[i+1] + model.compartment_diameters[i])*np.pi*m[i]*0.5\\n for i in range(0,model.nof_comps)]\\n \\n ##### Noise term\\n model.P_Na_vector = np.zeros(model.nof_comps)*um/second\\n model.P_Na_vector[model.structure == 2] = model.P_Na\\n model.noise_term = np.sqrt(model.A_surface*model.P_Na_vector)\\n \\n ##### Compartments to plot\\n model.comps_to_plot = range(1,model.nof_comps)\\n \\n ##### initialize defaultclock\\n defaultclock.dt = dt\\n\\n ##### define morphology\\n morpho = Section(n = model.nof_comps,\\n length = model.compartment_lengths,\\n diameter = model.compartment_diameters)\\n \\n ##### define neuron\\n neuron = SpatialNeuron(morphology = morpho,\\n model = model.eqs,\\n Cm = model.c_m,\\n Ri = model.rho_in,\\n method=\\\"exponential_euler\\\")\\n \\n ##### initial values\\n neuron.v = model.V_res\\n neuron.m = model.m_init\\n neuron.n = model.n_init\\n neuron.h = model.h_init\\n \\n ##### Set parameter values of differential equations\\n # conductances active compartments\\n neuron.g_Na = model.g_Na\\n neuron.g_K = model.g_K\\n \\n # conductances internodes\\n neuron.g_Na[np.asarray(np.where(model.structure == 1))] = 0*msiemens/cm**2\\n neuron.g_K[np.asarray(np.where(model.structure == 1))] = 0*msiemens/cm**2\\n \\n # other parameters\\n neuron.V_res = model.V_res\\n neuron.T_celsius = model.T_celsius\\n neuron.E_Na = model.E_Na\\n neuron.E_K = model.E_K\\n neuron.E_L = model.E_L\\n neuron.g_L = model.g_L \\n \\n return neuron, model\",\n \"def get_model(model_name: str = \\\"\\\", cfg={}) -> torch.nn.Module:\\n if model_name == \\\"default\\\":\\n model = AudioNTT2020(n_mels=cfg.n_mels, d=cfg.feature_d)\\n\\n elif model_name == \\\"resnetish34\\\":\\n model = resnetish34()\\n\\n elif model_name == \\\"clstm\\\":\\n model = CLSTM()\\n\\n elif model_name == \\\"cvt\\\":\\n s1_depth, s2_depth, s3_depth = cfg.depths\\n s1_emb_dim, s2_emb_dim, s3_emb_dim = cfg.embed_dims\\n s1_mlp_mult, s2_mlp_mult, s3_mlp_mult = cfg.mlp_mults\\n\\n model = CvT(\\n s1_emb_dim=s1_emb_dim,\\n s1_depth=s1_depth,\\n s1_mlp_mult=s1_mlp_mult,\\n s2_emb_dim=s2_emb_dim,\\n s2_depth=s2_depth,\\n s2_mlp_mult=s2_mlp_mult,\\n s3_emb_dim=s3_emb_dim,\\n s3_depth=s3_depth,\\n s3_mlp_mult=s3_mlp_mult,\\n pool=cfg.cvt_pool,\\n )\\n else:\\n raise ValueError(\\\"Model not found.\\\")\\n return model\",\n \"def parse_temp_model(self, default=None):\\n\\t\\tcfg_temp_model = self.cfg_root.find('temp_model')\\n\\n\\t\\tif cfg_temp_model and cfg_temp_model.text in self.VALID_TEMP_MODEL:\\n\\t\\t\\tcfg_temp_model = cfg_temp_model.text\\n\\t\\telse:\\n\\t\\t\\tcfg_temp_model = default\\n\\n\\t\\treturn cfg_temp_model\",\n \"def _scaling_model_from_dict(obj):\\n for entry_point in pkg_resources.iter_entry_points(\\\"dxtbx.scaling_model_ext\\\"):\\n if entry_point.name == obj[\\\"__id__\\\"]:\\n return entry_point.load().from_dict(obj)\",\n \"def _init_model(\\n self,\\n cfg: ConfigType,\\n weights: Optional[str],\\n device: str = 'cpu',\\n ) -> nn.Module:\\n checkpoint: Optional[dict] = None\\n if weights is not None:\\n checkpoint = _load_checkpoint(weights, map_location='cpu')\\n\\n if not cfg:\\n assert checkpoint is not None\\n try:\\n # Prefer to get config from `message_hub` since `message_hub`\\n # is a more stable module to store all runtime information.\\n # However, the early version of MMEngine will not save config\\n # in `message_hub`, so we will try to load config from `meta`.\\n cfg_string = checkpoint['message_hub']['runtime_info']['cfg']\\n except KeyError:\\n assert 'meta' in checkpoint, (\\n 'If model(config) is not provided, the checkpoint must'\\n 'contain the config string in `meta` or `message_hub`, '\\n 'but both `meta` and `message_hub` are not found in the '\\n 'checkpoint.')\\n meta = checkpoint['meta']\\n if 'cfg' in meta:\\n cfg_string = meta['cfg']\\n else:\\n raise ValueError(\\n 'Cannot find the config in the checkpoint.')\\n cfg.update(\\n Config.fromstring(cfg_string, file_format='.py')._cfg_dict)\\n\\n # Delete the `pretrained` field to prevent model from loading the\\n # the pretrained weights unnecessarily.\\n if cfg.model.get('pretrained') is not None:\\n del cfg.model.pretrained\\n\\n model = MODELS.build(cfg.model)\\n model.cfg = cfg\\n self._load_weights_to_model(model, checkpoint, cfg)\\n model.to(device)\\n model.eval()\\n return model\",\n \"def run_model(config_file):\\n config_file = os.path.join(os.getcwd(), config_file)\\n result = Tethys(config_file=config_file)\\n result.run_model()\\n return result\",\n \"def create_model(config_obj: Union[ModelConfig, dict], random_seed: int = default_random_seed) -> BaseModel:\\n if isinstance(config_obj, dict):\\n config_obj = ModelConfig.from_dict(config_obj)\\n model_type = get_from_registry(config_obj.model_type, model_type_registry)\\n return model_type(config_obj, random_seed=random_seed)\",\n \"def scale_model(model,scaleparname='A',scaleval=1):\\n model = get_model_instance(model)\\n if scaleparname in model.params:\\n scaleparname += '1'\\n if isinstance(model,FunctionModel1D):\\n compclass = CompositeModel1D\\n else:\\n compclass = CompositeModel\\n res = compclass((model,'constant'),operation='*',\\n parnames={'C1':scaleparname})\\n setattr(res,scaleparname,scaleval)\\n return res\",\n \"def make(model: Type[Model], **kwargs: Any) -> Model:\\n return modelfactory_factory(model)(**kwargs)\",\n \"def model_fn(features, labels, mode, params): # pylint: disable=unused-argument\\n\\n tf.logging.info(\\\"*** Features ***\\\")\\n for name in sorted(features.keys()):\\n tf.logging.info(\\\" name = %s, shape = %s\\\" % (name, features[name].shape))\\n\\n input_ids = features[\\\"input_ids\\\"]\\n input_mask = features[\\\"input_mask\\\"]\\n segment_ids = features[\\\"segment_ids\\\"]\\n label_ids = features[\\\"label_ids\\\"]\\n\\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\\n\\n (total_loss, per_example_loss, logits, probabilities) = model_function.create(\\n bert_config, is_training, input_ids, input_mask, segment_ids, label_ids,\\n num_labels, use_one_hot_embeddings)\\n\\n tvars = tf.trainable_variables()\\n initialized_variable_names = {}\\n scaffold_fn = None\\n if init_checkpoint:\\n (assignment_map, initialized_variable_names\\n ) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\\n if use_tpu:\\n\\n def tpu_scaffold():\\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n return tf.train.Scaffold()\\n\\n scaffold_fn = tpu_scaffold\\n else:\\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n\\n tf.logging.info(\\\"**** Trainable Variables ****\\\")\\n for var in tvars:\\n init_string = \\\"\\\"\\n if var.name in initialized_variable_names:\\n init_string = \\\", *INIT_FROM_CKPT*\\\"\\n tf.logging.info(\\\" name = %s, shape = %s%s\\\", var.name, var.shape,\\n init_string)\\n\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n\\n train_op = optimization.create_optimizer(\\n total_loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu,\\n scope=(\\\"loss\\\" if model_function.freeze else None))\\n\\n output_spec = tf.contrib.tpu.TPUEstimatorSpec(\\n mode=mode,\\n loss=total_loss,\\n train_op=train_op,\\n scaffold_fn=scaffold_fn)\\n elif mode == tf.estimator.ModeKeys.EVAL:\\n\\n if model_function.task_type == TaskType.CLASSIFICATION:\\n\\n def metric_fn(per_example_loss, label_ids, logits):\\n predictions = tf.argmax(logits, axis=-1, output_type=tf.int32)\\n accuracy = tf.metrics.accuracy(label_ids, predictions)\\n loss = tf.metrics.mean(per_example_loss)\\n return {\\n \\\"eval_accuracy\\\": accuracy,\\n \\\"eval_loss\\\": loss,\\n }\\n elif model_function.task_type == TaskType.REGRESSION:\\n\\n def metric_fn(per_example_loss, label_ids, logits):\\n ground_truth = tf.log1p(tf.clip_by_value(tf.cast(label_ids, tf.float32), 1e-8, 1e+30))\\n predictions = tf.log1p(tf.clip_by_value(logits, 1e-8, 1e+30))\\n return {\\n \\\"eval_loss\\\": tf.metrics.mean(per_example_loss),\\n \\\"another_loss\\\": tf.metrics.mean_squared_error(ground_truth, predictions)\\n }\\n else:\\n raise NotImplementedError()\\n\\n eval_metrics = (metric_fn, [per_example_loss, label_ids, logits])\\n output_spec = tf.contrib.tpu.TPUEstimatorSpec(\\n mode=mode,\\n loss=total_loss,\\n eval_metrics=eval_metrics,\\n scaffold_fn=scaffold_fn)\\n else:\\n predictions = {\\n \\\"result\\\": probabilities\\n }\\n print(probabilities.shape)\\n print(type(probabilities))\\n\\n output_spec = tf.contrib.tpu.TPUEstimatorSpec(\\n mode=mode, predictions=predictions, scaffold_fn=scaffold_fn)\\n return output_spec\",\n \"def create(name, out_channel, pretrain):\\n if out_channel == 10 or out_channel == 100 or out_channel == 200:\\n # use custom models\\n if name not in custom_factory:\\n raise KeyError(\\\"Unknown model:\\\", name)\\n return custom_factory[name](out_channel)\\n elif out_channel == 1000:\\n if name not in torchvision_factory:\\n raise KeyError(\\\"Unknown model:\\\", name)\\n return torchvision_factory[name](pretrain)\\n else:\\n raise Exception\",\n \"def make_model(self, options, generator):\\n model_type = options.model_type\\n input_shape = (options.target_size[0], options.target_size[1],\\n len(options.active_input_inds))\\n nb_labels = generator.dataset.nb_labels\\n\\n if model_type == CONV_LOGISTIC:\\n model = make_conv_logistic(input_shape, nb_labels,\\n options.kernel_size)\\n elif model_type == FCN_RESNET:\\n model = make_fcn_resnet(\\n input_shape, nb_labels, options.use_pretraining,\\n options.freeze_base)\\n elif model_type == DUAL_FCN_RESNET:\\n model = make_dual_fcn_resnet(\\n input_shape, options.dual_active_input_inds,\\n nb_labels, options.use_pretraining, options.freeze_base)\\n elif model_type == UNET:\\n model = make_unet(input_shape, nb_labels)\\n elif model_type == FC_DENSENET:\\n model = make_fc_densenet(\\n input_shape, nb_labels, drop_prob=options.drop_prob,\\n weight_decay=options.weight_decay,\\n down_blocks=options.down_blocks,\\n up_blocks=options.up_blocks)\\n elif model_type in [CONCAT_ENSEMBLE, AVG_ENSEMBLE]:\\n models, active_input_inds_list = self.load_ensemble_models(options)\\n if model_type == CONCAT_ENSEMBLE:\\n model = ConcatEnsemble(\\n models, active_input_inds_list, input_shape, nb_labels)\\n elif model_type == AVG_ENSEMBLE:\\n model = AvgEnsemble(models, active_input_inds_list)\\n else:\\n raise ValueError('{} is not a valid model_type'.format(model_type))\\n\\n return model\",\n \"def model_fn(features, labels, mode, params): # pylint: disable=unused-argument\\n\\n # tf.logging.info(\\\"*** Features ***\\\")\\n # for name in sorted(features.keys()):\\n # tf.logging.info(\\\" name = %s, shape = %s\\\" % (name, features[name].shape))\\n\\n input_ids = features[\\\"input_ids\\\"]\\n input_mask = features[\\\"input_mask\\\"]\\n segment_ids = features[\\\"segment_ids\\\"]\\n label_ids = features[\\\"label_ids\\\"]\\n\\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\\n\\n (total_loss, per_example_loss, logits, probabilities) = create_model(\\n bert_config, is_training, input_ids, input_mask, segment_ids, label_ids,\\n num_labels, use_one_hot_embeddings)\\n\\n # output_spec = tf.contrib.tpu.TPUEstimatorSpec(\\n # mode=tf.estimator.ModeKeys.PREDICT,\\n # predictions=probabilities)\\n output_spec = tf.estimator.EstimatorSpec(\\n mode=tf.estimator.ModeKeys.PREDICT,\\n predictions=probabilities\\n )\\n return output_spec\",\n \"def model_fn(features, labels, mode, params):\\n utils.log(\\\"Building model...\\\")\\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\\n model = FinetuningModel(\\n config, tasks, is_training, features, num_train_steps)\\n\\n if pretraining_config is not None:\\n # init_checkpoint = tf.train.latest_checkpoint(pretraining_config.model_dir)\\n init_checkpoint = pretraining_config['checkpoint']\\n utils.log(\\\"Using checkpoint\\\", init_checkpoint)\\n tvars = tf.trainable_variables()\\n scaffold_fn = None\\n if init_checkpoint:\\n assignment_map, _ = modeling.get_assignment_map_from_checkpoint(\\n tvars, init_checkpoint)\\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n\\n # Build model for training or prediction\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n train_op = optimization.create_optimizer(\\n model.loss, config.learning_rate, num_train_steps,\\n weight_decay_rate=config.weight_decay_rate,\\n use_tpu=config.use_tpu,\\n warmup_proportion=config.warmup_proportion,\\n layerwise_lr_decay_power=config.layerwise_lr_decay,\\n n_transformer_layers=model.bert_config.num_hidden_layers\\n )\\n output_spec = tf.estimator.tpu.TPUEstimatorSpec(\\n mode=mode,\\n loss=model.loss,\\n train_op=train_op,\\n scaffold_fn=scaffold_fn,\\n training_hooks=[training_utils.ETAHook(\\n {} if config.use_tpu else dict(loss=model.loss),\\n num_train_steps, config.iterations_per_loop, config.use_tpu, 10)])\\n else:\\n assert mode == tf.estimator.ModeKeys.PREDICT\\n output_spec = tf.estimator.tpu.TPUEstimatorSpec(\\n mode=mode,\\n predictions=utils.flatten_dict(model.outputs),\\n scaffold_fn=scaffold_fn)\\n\\n utils.log(\\\"Building complete\\\")\\n return output_spec\",\n \"def transformerXLModel(*args, **kwargs):\\n model = TransfoXLModel.from_pretrained(*args, **kwargs)\\n return model\",\n \"def CreateModel(self, request, timeout, metadata=None, with_call=False, protocol_options=None):\\n raise NotImplementedError()\",\n \"def create_supervised_evaluator(\\n model, prepare_batch, metrics=None, device=None, non_blocking=False, output_transform=val_transform,\\n):\\n metrics = metrics or {}\\n\\n if device:\\n model.to(device)\\n\\n def _inference(engine, batch):\\n model.eval()\\n with torch.no_grad():\\n x, y, ids, patch_locations = prepare_batch(batch, device=device, non_blocking=non_blocking)\\n y_pred = model(x)\\n y_pred = _upscale_model_output(y_pred, x)\\n return output_transform(x, y, y_pred, ids, patch_locations)\\n\\n engine = Engine(_inference)\\n\\n for name, metric in metrics.items():\\n metric.attach(engine, name)\\n\\n return engine\",\n \"def createModel(config_path, checkpoint_path, graph_path):\\n\\n global build_graph, prev_classes\\n\\n trt_graph = None\\n input_names = None\\n \\n if build_graph:\\n frozen_graph, input_names, output_names = build_detection_graph(\\n config=config_path,\\n checkpoint=checkpoint_path\\n )\\n \\n trt_graph = trt.create_inference_graph(\\n input_graph_def=frozen_graph,\\n outputs=output_names,\\n max_batch_size=1,\\n max_workspace_size_bytes=1 << 25,\\n precision_mode='FP16',\\n minimum_segment_size=50\\n )\\n\\n with open(graph_path, 'wb') as f:\\n f.write(trt_graph.SerializeToString())\\n\\n with open('config.txt', 'r+') as json_file: \\n data = json.load(json_file)\\n data['model'] = []\\n data['model'] = [{'input_names': input_names}]\\n json_file.seek(0)\\n json_file.truncate()\\n json.dump(data, json_file)\\n\\n else:\\n with open(graph_path, 'rb') as f:\\n trt_graph = tf.GraphDef()\\n trt_graph.ParseFromString(f.read())\\n with open('config.txt') as json_file: \\n data = json.load(json_file)\\n input_names = data['model'][0]['input_names']\\n\\n return Model(trt_graph, input_names)\",\n \"def recent_model_init(model_args, task_infos, tokenizer):\\n config = AutoConfig.from_pretrained(\\n model_args.model_name_or_path,\\n num_labels=task_infos.num_labels,\\n cache_dir=model_args.model_cache_dir,\\n id2label=task_infos.id2label,\\n label2id=task_infos.label2id,\\n )\\n config.dense_type = model_args.dense_type\\n config.act_type = model_args.act_type\\n config.num_labels_per_head = [\\n len(label_id) for label_id in task_infos.head_id_to_label_id\\n ]\\n config.head2label = task_infos.head_id_to_label_id\\n model_cls = getattr(mod, model_args.architectures,\\n RobertaForKlueRecent)\\n model = model_cls.from_pretrained(\\n model_args.model_name_or_path,\\n config=config,\\n cache_dir=model_args.model_cache_dir,\\n )\\n if model.config.vocab_size < len(tokenizer):\\n print(\\\"resize...\\\")\\n model.resize_token_embeddings(len(tokenizer))\\n return model\",\n \"def initialize_model_from_cfg(args, gpu_id=0):\\n model = eval(args.model).loot_model(args)\\n model.eval()\\n\\n if args.cuda:\\n model.cuda()\\n\\n if args.load_ckpt:\\n load_name = args.load_ckpt\\n logger.info(\\\"loading checkpoint %s\\\", load_name)\\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\\n net_utils.load_ckpt(model, checkpoint['model'])\\n\\n if args.load_detectron:\\n logger.info(\\\"loading detectron weights %s\\\", args.load_detectron)\\n load_detectron_weight(model, args.load_detectron)\\n\\n\\n return model\",\n \"def create_model(self):\\r\\n model = self.model_fn(self.flags)\\r\\n print(model)\\r\\n return model\",\n \"def optimize_model(input,\\n model_type='bert',\\n num_heads=0,\\n hidden_size=0,\\n optimization_options=None,\\n opt_level=0,\\n use_gpu=False,\\n only_onnxruntime=False):\\n (optimizer_class, producer, run_onnxruntime) = MODEL_CLASSES[model_type]\\n\\n temp_model_path = None\\n if opt_level > 1: # Optimization specified for an execution provider.\\n temp_model_path = optimize_by_onnxruntime(input, use_gpu=use_gpu, opt_level=opt_level)\\n elif run_onnxruntime:\\n # Use Onnxruntime to do optimizations (like constant folding and cast elimation) that is not specified to exection provider.\\n # CPU provider is used here so that there is no extra node for GPU memory copy.\\n temp_model_path = optimize_by_onnxruntime(input, use_gpu=False, opt_level=1)\\n\\n model = load_model(temp_model_path or input, format=None, load_external_data=True)\\n\\n if model.producer_name and producer != model.producer_name:\\n logger.warning(\\n f\\\"Model producer not matched: Expect {producer}, Got {model.producer_name} {model.producer_version}. Please specify correct --model_type parameter.\\\"\\n )\\n\\n if optimization_options is None:\\n optimization_options = BertOptimizationOptions(model_type)\\n\\n optimizer = optimizer_class(model, num_heads, hidden_size)\\n\\n if not only_onnxruntime:\\n optimizer.optimize(optimization_options)\\n\\n # Remove the temporary model.\\n if temp_model_path:\\n os.remove(temp_model_path)\\n logger.debug(\\\"Remove tempoary model: {}\\\".format(temp_model_path))\\n\\n optimizer.model.producer_name = \\\"onnxruntime.transformers\\\"\\n from onnxruntime import __version__ as onnxruntime_version\\n optimizer.model.producer_version = onnxruntime_version\\n\\n return optimizer\",\n \"def generate_model(**kwargs):\\n model = ResNet3D(Bottleneck, [3, 4, 6, 3], [64, 128, 256, 512], **kwargs)\\n return model\",\n \"def basic_model_init(model_args, task_infos, tokenizer):\\n config = AutoConfig.from_pretrained(\\n model_args.model_name_or_path,\\n num_labels=task_infos.num_labels,\\n cache_dir=model_args.model_cache_dir,\\n id2label=task_infos.id2label,\\n label2id=task_infos.label2id,\\n )\\n model_cls = getattr(mod, model_args.architectures,\\n AutoModelForSequenceClassification)\\n model = model_cls.from_pretrained(\\n model_args.model_name_or_path,\\n config=config,\\n cache_dir=model_args.model_cache_dir,\\n )\\n if model.config.vocab_size < len(tokenizer):\\n print(\\\"resize...\\\")\\n model.resize_token_embeddings(len(tokenizer))\\n return model\",\n \"def model_creator(config):\\n return nn.Linear(1, 1)\",\n \"def set_temperature(logits, label):\\n nll_criterion = nn.CrossEntropyLoss().to(device)\\n\\n class TemperatureModel(nn.Module):\\n def __init__(self):\\n super().__init__()\\n self.temperature = nn.Parameter(torch.ones(1) * 1.5)\\n\\n def forward(self, logits):\\n temperature = self.temperature.unsqueeze(1).expand(logits.size(0), logits.size(1))\\n logits = logits / temperature\\n return logits, self.temperature\\n\\n model_T = TemperatureModel()\\n optimizer = optim.Adam(\\n model_T.parameters(), lr=0.01, weight_decay=1e-4\\n )\\n for i in range(40):\\n TC_pred, _ = model_T(logits)\\n optimizer.zero_grad()\\n loss = nll_criterion(TC_pred, label)\\n loss.backward()\\n optimizer.step()\\n\\n _, T = model_T(logits)\\n return T\",\n \"def create_model(self):\\n pass\",\n \"def create_model(self):\\n pass\",\n \"def _make_model_v1():\\n tf.reset_default_graph()\\n\\n with tf.Session() as sess:\\n # Make two simple graphs, both of which will be served by TF\\n x = tf.placeholder('float', shape=(None, 3), name='Input')\\n z = tf.placeholder('float', shape=(), name='ScalarMultiple')\\n m = tf.Variable([1.0, 1.0, 1.0], name='Slopes')\\n y = m * x + 1\\n len_fun = tf.reduce_sum(y - x) # Returns the number of elements in the array\\n scale_mult = tf.multiply(z, x, name='scale_mult')\\n\\n # Initialize the variables\\n init = tf.global_variables_initializer()\\n sess.run(init)\\n\\n # Create the tool for saving the model to disk\\n builder = tf.saved_model.builder.SavedModelBuilder(tf_export_path)\\n\\n # Make descriptions for the inputs and outputs\\n x_desc = tf.saved_model.utils.build_tensor_info(x)\\n y_desc = tf.saved_model.utils.build_tensor_info(y)\\n z_desc = tf.saved_model.utils.build_tensor_info(z)\\n len_fun_desc = tf.saved_model.utils.build_tensor_info(len_fun)\\n scale_mult_desc = tf.saved_model.utils.build_tensor_info(scale_mult)\\n\\n # Make a signature for the functions to be served\\n func_sig = tf.saved_model.signature_def_utils.build_signature_def(\\n inputs={'x': x_desc},\\n outputs={'y': y_desc},\\n method_name='run'\\n )\\n len_sig = tf.saved_model.signature_def_utils.build_signature_def(\\n inputs={'x': x_desc},\\n outputs={'len': len_fun_desc},\\n method_name='length'\\n )\\n mult_sig = tf.saved_model.signature_def_utils.build_signature_def(\\n inputs={'x': x_desc, 'z': z_desc},\\n outputs={'scale_mult': scale_mult_desc},\\n method_name='scalar_multiply'\\n )\\n\\n # Add the functions and the state of the graph to the builder\\n builder.add_meta_graph_and_variables(\\n sess, [tf.saved_model.tag_constants.SERVING],\\n signature_def_map={\\n tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: func_sig,\\n 'length': len_sig,\\n 'scalar_multiply': mult_sig\\n })\\n\\n # Save the function\\n builder.save()\",\n \"def from_pretrained(cls,\\n *args,\\n **kwargs):\\n pretrained_model_name_or_path = kwargs.get(\\\"pretrained_model_name_or_path\\\", None) \\\\\\n if len(args) == 0 else args[0]\\n config_dict, _ = PretrainedConfig.get_config_dict(pretrained_model_name_or_path)\\n bigdl_transformers_low_bit = config_dict.pop(\\\"bigdl_transformers_low_bit\\\", False)\\n invalidInputError(not bigdl_transformers_low_bit,\\n f\\\"Detected model is a low-bit({bigdl_transformers_low_bit}) model, \\\"\\n f\\\"Please use load_low_bit to load this model.\\\")\\n\\n # For huggingface transformers cls.HF_Model.from_pretrained could only restore the model\\n # in the original format, which is not quantized,\\n # we can convert the model to quantized later.\\n load_in_4bit = kwargs.pop(\\\"load_in_4bit\\\", False)\\n load_in_low_bit = kwargs.pop(\\\"load_in_low_bit\\\", None)\\n optimize_model = kwargs.pop(\\\"optimize_model\\\", True)\\n\\n if load_in_4bit or load_in_low_bit:\\n # load int x-bit\\n kwargs[\\\"low_cpu_mem_usage\\\"] = True\\n # set default torch_dtype='auto'\\n kwargs[\\\"torch_dtype\\\"] = kwargs.get(\\\"torch_dtype\\\", 'auto')\\n # Avoid tensor parallel F.Linear Operations\\n if \\\"pretraining_tp\\\" in config_dict:\\n kwargs[\\\"pretraining_tp\\\"] = 1\\n q_k = load_in_low_bit if load_in_low_bit else \\\"sym_int4\\\"\\n model = cls.load_convert(q_k, optimize_model, *args, **kwargs)\\n else:\\n # load default\\n model = cls.HF_Model.from_pretrained(*args, **kwargs)\\n\\n return model\",\n \"def set_temperature2(logits, label):\\n\\n nll_criterion = nn.CrossEntropyLoss().to(device)\\n\\n class TemperatureModel(nn.Module):\\n def __init__(self):\\n super().__init__()\\n self.temperature = nn.Parameter(torch.ones(1) * 1.5)\\n\\n def forward(self, logits):\\n temperature = self.temperature.unsqueeze(1).expand(logits.size(0), logits.size(1))\\n logits = logits / temperature\\n return logits, self.temperature\\n\\n model_T = TemperatureModel()\\n optimizer = optim.Adam(\\n model_T.parameters(), lr=0.01, weight_decay=1e-4\\n )\\n for i in range(40):\\n TC_pred, _ = model_T(logits)\\n optimizer.zero_grad()\\n loss = nll_criterion(TC_pred, label)\\n loss.backward()\\n optimizer.step()\\n\\n _, T = model_T(logits)\\n return T\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73296446","0.57077694","0.570612","0.57056636","0.56610817","0.55574673","0.54785675","0.5419638","0.53965676","0.53905576","0.538604","0.538604","0.5313637","0.52842414","0.52818054","0.5228253","0.5218954","0.5209238","0.52031755","0.5201383","0.51910466","0.51866466","0.5161635","0.515062","0.5128692","0.5108899","0.5107936","0.5107017","0.5105261","0.5101205","0.50903654","0.5081285","0.504077","0.50379235","0.5030885","0.5024988","0.50151837","0.49843875","0.49791056","0.49639997","0.49568135","0.49551764","0.4940765","0.4937491","0.4931022","0.49306655","0.49292192","0.49114683","0.48930836","0.48929816","0.4892956","0.48923966","0.48773983","0.48705","0.48531246","0.48494416","0.4841089","0.48410282","0.48405635","0.48390466","0.48375046","0.48321953","0.48213097","0.48201022","0.48179272","0.48125222","0.48040283","0.48035505","0.48028344","0.47996506","0.47974712","0.47951767","0.47940215","0.47814786","0.47808978","0.4777628","0.4776726","0.47673738","0.476675","0.4766639","0.4757638","0.47422272","0.47372547","0.47329733","0.47325525","0.47305018","0.47280627","0.4721701","0.4719108","0.471823","0.47165692","0.47144204","0.47108465","0.47106728","0.4710142","0.47099254","0.47099254","0.4697651","0.46956053","0.46901697"],"string":"[\n \"0.73296446\",\n \"0.57077694\",\n \"0.570612\",\n \"0.57056636\",\n \"0.56610817\",\n \"0.55574673\",\n \"0.54785675\",\n \"0.5419638\",\n \"0.53965676\",\n \"0.53905576\",\n \"0.538604\",\n \"0.538604\",\n \"0.5313637\",\n \"0.52842414\",\n \"0.52818054\",\n \"0.5228253\",\n \"0.5218954\",\n \"0.5209238\",\n \"0.52031755\",\n \"0.5201383\",\n \"0.51910466\",\n \"0.51866466\",\n \"0.5161635\",\n \"0.515062\",\n \"0.5128692\",\n \"0.5108899\",\n \"0.5107936\",\n \"0.5107017\",\n \"0.5105261\",\n \"0.5101205\",\n \"0.50903654\",\n \"0.5081285\",\n \"0.504077\",\n \"0.50379235\",\n \"0.5030885\",\n \"0.5024988\",\n \"0.50151837\",\n \"0.49843875\",\n \"0.49791056\",\n \"0.49639997\",\n \"0.49568135\",\n \"0.49551764\",\n \"0.4940765\",\n \"0.4937491\",\n \"0.4931022\",\n \"0.49306655\",\n \"0.49292192\",\n \"0.49114683\",\n \"0.48930836\",\n \"0.48929816\",\n \"0.4892956\",\n \"0.48923966\",\n \"0.48773983\",\n \"0.48705\",\n \"0.48531246\",\n \"0.48494416\",\n \"0.4841089\",\n \"0.48410282\",\n \"0.48405635\",\n \"0.48390466\",\n \"0.48375046\",\n \"0.48321953\",\n \"0.48213097\",\n \"0.48201022\",\n \"0.48179272\",\n \"0.48125222\",\n \"0.48040283\",\n \"0.48035505\",\n \"0.48028344\",\n \"0.47996506\",\n \"0.47974712\",\n \"0.47951767\",\n \"0.47940215\",\n \"0.47814786\",\n \"0.47808978\",\n \"0.4777628\",\n \"0.4776726\",\n \"0.47673738\",\n \"0.476675\",\n \"0.4766639\",\n \"0.4757638\",\n \"0.47422272\",\n \"0.47372547\",\n \"0.47329733\",\n \"0.47325525\",\n \"0.47305018\",\n \"0.47280627\",\n \"0.4721701\",\n \"0.4719108\",\n \"0.471823\",\n \"0.47165692\",\n \"0.47144204\",\n \"0.47108465\",\n \"0.47106728\",\n \"0.4710142\",\n \"0.47099254\",\n \"0.47099254\",\n \"0.4697651\",\n \"0.46956053\",\n \"0.46901697\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8471851"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4487,"cells":{"query":{"kind":"string","value":"Initialize your data structure here."},"document":{"kind":"string","value":"def __init__(self):\n self.buckets = collections.defaultdict(list)"},"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_empty(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self.data = []\n self.record = {}","def initialize(self):\n self.data = None\n self.errors = []","def initialize(self):\n\t\tpass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\r\n pass","def initialize(self):\r\n pass","def __init__(self):\n self.structure = {}","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def __init__(self):\n\n # initialise the empty mappings dictionary\n self.data = {\n 'loan_id': None,\n 'product': None,\n 'origination_date': None,\n 'reversion_date': None,\n 'rate_term': None,\n 'loan_amount': None,\n 'initial_rate': None,\n 'reversion_rate': None,\n 'term': None,\n 'interest_only_amount': None,\n 'upfront_fees': None,\n 'upfront_costs': None,\n 'entity_eir': None\n }","def __init__(self):\n self._data = [] # non-public underlying Python list as storage","def __init__(self):\n self._distance_data = []\n self._location_data = []\n self._package_data = []","def __init__(self):\n\t\tsuper().__init__()\n\t\t\n\t\t# Typically a list of data here\n\t\t# Typically a dict of header keys and values here","def __init__(self):\n self.data = []","def __init__(self):\n self.data = []","def __init__(self):\n self.data = []\n self.idx = {}","def __init__(self):\n self._dict = {}\n self._array = []","def init(self) -> None:","def __init__(self):\n self.relation = ''\n self.attributes = []\n self.attribute_types = dict()\n self.attribute_data = dict()\n self.comment = []\n self.data = []\n pass","def _init(self):\n pass","def initialize(self):\n return","def initialize(self):\n self.muondEdx = []\n self.muondNdx = []\n self.muonmomentum = []\n self.piondEdx = []\n self.piondNdx = []\n self.pionmomentum = []\n self.kaondEdx = []\n self.kaondNdx = []\n self.kaonmomentum = []\n self.protdEdx = []\n self.protdNdx = []\n self.protmomentum = []\n self.elecdEdx = []\n self.elecdNdx = []\n self.elecmomentum = []","def initialize(self) -> None:\n pass","def initialize(self):\n pass # pragma: no cover","def __init__(self):\n self.d = {}\n self.l = []","def _initialize(self):\n pass","def _initialize(self):\n pass","def _initialize(self):\n pass","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def initialise(self):","def __init__(self):\n self.l = {}\n self.s = {}","def __init__(self):\n self._data=[]","def __init__(self, initial_data=[]):\n hdict.__init__(self)\n\n for elt in initial_data:\n self.add(elt)","def initialize(self):","def initialize(self):","def initialize(self):","def initialize(self):","def init(self):\n raise NotImplementedError","def init(self):\n raise NotImplementedError","def init(self) -> None:\n ...","def initialize(self):\n\n db = dict()\n\n db['meta'] = Meta(None)\n db['race'] = Race(None, None, None, None, None)\n db['track'] = Track(None, None)\n db['classes'] = set([])\n db['teams'] = set([])\n db['drivers'] = set([])\n\n self.db = db","def __init__(self):\n self.keys = []\n self.values = []","def __init__(self):\n self.d = {}\n self.h = []","def memb_init(self):\n self.initialize()","def __init__(self):\n self.dic={}\n self.data=[]","def _init_data(self) -> None:\n self.dtype = dict()\n self.shape = dict()\n self.size = dict()\n self.attrs = dict()\n self.data_ptr = dict()\n\n if self.mode == 'r':\n for k in self.fp.keys():\n self.dtype[k] = self.fp[k].dtype\n self.shape[k] = self.fp[k].shape\n self.size[k] = self.fp[k].shape[0]\n self.data_ptr[k] = 0","def __init__(self):\n dict.__init__(self)\n self.datatype = None","def __init__(self, data={}):\n self._update_(data)","def _init_data(self, data):\n assert type(data) is dict, \"dict expected: %r\" % type(data)\n assert len(data) is 1, \"size of dict should be 1: %r\" % len(data)\n self._name = data.keys()[0]\n self._data = np.asarray(data[self._name])\n self._set = True","def __init__(self):\n self._data = PositionalList() # list of _Item instances","def __init__(self):\n self.d = {}","def __init__(self):\n self.d = {}","def __init__(self):\n self.d = {}","def __init__(self):\n self.d = {}","def _init(self):\n raise NotImplementedError","def __init__(self):\r\n self.indices = {}\r\n self.data = []\r\n self.len = 0","def __init__(self):\n self.metadata = {}\n self.geometry = {'array': None, \n 'geom': None, \n 'wkt': None}","def __init__(self, data):\n self.data = data\n return","def __init__(self):\n self.root = [None, dict(), False] # val, sons, end-able","def _initialize_data(self):\n self.unique_id = 123\n\n self.gas_valve_open = False\n self.buffer_valve_open = False\n self.pump_valve_open = False\n\n self.operatingmode = 0\n\n self.sample_pressure_high_limit = 100\n self.sample_pressure_low_limit = 10\n self.sample_pressure = 0\n\n self.error = 0\n\n self.buffer_pressure_high = True","def __init__(self):\n self.data = {}\n self.refresh()","def initialize(self):\n self.voteskips = []\n self.response = {}\n self.route = {}\n self.userlist = []\n self.poll = []\n self.media = []\n self.init = False\n self.question = None\n self.jumble = None\n self.imgur = None","def _initialize_data(self):\n self.reset_count = 0\n self._idn_no_firmware = \"KEPCO,BOP 50-20,E1234,\"\n self._firmware = 2.6\n self._init_data()","def init(self):","def init(self):","def __init__(self):\n self.x = {}\n self.len = 0\n self.annotations = {}","def __init__(self):\n # Dict of minecraft object in form of \"dict[id] = name\"\n self.data_values = dict()\n self.parser = self.setup_parser()","def initialize(self):\n self.keys = [None] * BUCKET_SIZE\n self.values = [None] * BUCKET_SIZE","def __init__(self, data: dict = {}):\n pass","def initialize(self): \r\n pass","def __init__(self):\n self._data = PositionalList() # list of Item instances","def __init__(self):\n self.table = {}\n self.ls = []","def initialize(self):\r\n self.bucket_array.initialize()","def initialise(self):\r\n return","def initialise(self):\r\n return","def __init__(self, data):\n self.data = data","def __init__(self, data):\n self.data = data","def __init__(self, data):\n self.data = data","def __init__(self, data):\n self.data = data","def __init__(self, data=None):\n self.data = data","def __init__(self):\n self._data = set()","def __init__(self):\n self.key_dict = {}\n self.value_dict = {}\n self.head, self.last = None, None"],"string":"[\n \"def _init_empty(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self.data = []\\n self.record = {}\",\n \"def initialize(self):\\n self.data = None\\n self.errors = []\",\n \"def initialize(self):\\n\\t\\tpass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\r\\n pass\",\n \"def __init__(self):\\n self.structure = {}\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def __init__(self):\\n\\n # initialise the empty mappings dictionary\\n self.data = {\\n 'loan_id': None,\\n 'product': None,\\n 'origination_date': None,\\n 'reversion_date': None,\\n 'rate_term': None,\\n 'loan_amount': None,\\n 'initial_rate': None,\\n 'reversion_rate': None,\\n 'term': None,\\n 'interest_only_amount': None,\\n 'upfront_fees': None,\\n 'upfront_costs': None,\\n 'entity_eir': None\\n }\",\n \"def __init__(self):\\n self._data = [] # non-public underlying Python list as storage\",\n \"def __init__(self):\\n self._distance_data = []\\n self._location_data = []\\n self._package_data = []\",\n \"def __init__(self):\\n\\t\\tsuper().__init__()\\n\\t\\t\\n\\t\\t# Typically a list of data here\\n\\t\\t# Typically a dict of header keys and values here\",\n \"def __init__(self):\\n self.data = []\",\n \"def __init__(self):\\n self.data = []\",\n \"def __init__(self):\\n self.data = []\\n self.idx = {}\",\n \"def __init__(self):\\n self._dict = {}\\n self._array = []\",\n \"def init(self) -> None:\",\n \"def __init__(self):\\n self.relation = ''\\n self.attributes = []\\n self.attribute_types = dict()\\n self.attribute_data = dict()\\n self.comment = []\\n self.data = []\\n pass\",\n \"def _init(self):\\n pass\",\n \"def initialize(self):\\n return\",\n \"def initialize(self):\\n self.muondEdx = []\\n self.muondNdx = []\\n self.muonmomentum = []\\n self.piondEdx = []\\n self.piondNdx = []\\n self.pionmomentum = []\\n self.kaondEdx = []\\n self.kaondNdx = []\\n self.kaonmomentum = []\\n self.protdEdx = []\\n self.protdNdx = []\\n self.protmomentum = []\\n self.elecdEdx = []\\n self.elecdNdx = []\\n self.elecmomentum = []\",\n \"def initialize(self) -> None:\\n pass\",\n \"def initialize(self):\\n pass # pragma: no cover\",\n \"def __init__(self):\\n self.d = {}\\n self.l = []\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialise(self):\",\n \"def __init__(self):\\n self.l = {}\\n self.s = {}\",\n \"def __init__(self):\\n self._data=[]\",\n \"def __init__(self, initial_data=[]):\\n hdict.__init__(self)\\n\\n for elt in initial_data:\\n self.add(elt)\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def init(self) -> None:\\n ...\",\n \"def initialize(self):\\n\\n db = dict()\\n\\n db['meta'] = Meta(None)\\n db['race'] = Race(None, None, None, None, None)\\n db['track'] = Track(None, None)\\n db['classes'] = set([])\\n db['teams'] = set([])\\n db['drivers'] = set([])\\n\\n self.db = db\",\n \"def __init__(self):\\n self.keys = []\\n self.values = []\",\n \"def __init__(self):\\n self.d = {}\\n self.h = []\",\n \"def memb_init(self):\\n self.initialize()\",\n \"def __init__(self):\\n self.dic={}\\n self.data=[]\",\n \"def _init_data(self) -> None:\\n self.dtype = dict()\\n self.shape = dict()\\n self.size = dict()\\n self.attrs = dict()\\n self.data_ptr = dict()\\n\\n if self.mode == 'r':\\n for k in self.fp.keys():\\n self.dtype[k] = self.fp[k].dtype\\n self.shape[k] = self.fp[k].shape\\n self.size[k] = self.fp[k].shape[0]\\n self.data_ptr[k] = 0\",\n \"def __init__(self):\\n dict.__init__(self)\\n self.datatype = None\",\n \"def __init__(self, data={}):\\n self._update_(data)\",\n \"def _init_data(self, data):\\n assert type(data) is dict, \\\"dict expected: %r\\\" % type(data)\\n assert len(data) is 1, \\\"size of dict should be 1: %r\\\" % len(data)\\n self._name = data.keys()[0]\\n self._data = np.asarray(data[self._name])\\n self._set = True\",\n \"def __init__(self):\\n self._data = PositionalList() # list of _Item instances\",\n \"def __init__(self):\\n self.d = {}\",\n \"def __init__(self):\\n self.d = {}\",\n \"def __init__(self):\\n self.d = {}\",\n \"def __init__(self):\\n self.d = {}\",\n \"def _init(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\r\\n self.indices = {}\\r\\n self.data = []\\r\\n self.len = 0\",\n \"def __init__(self):\\n self.metadata = {}\\n self.geometry = {'array': None, \\n 'geom': None, \\n 'wkt': None}\",\n \"def __init__(self, data):\\n self.data = data\\n return\",\n \"def __init__(self):\\n self.root = [None, dict(), False] # val, sons, end-able\",\n \"def _initialize_data(self):\\n self.unique_id = 123\\n\\n self.gas_valve_open = False\\n self.buffer_valve_open = False\\n self.pump_valve_open = False\\n\\n self.operatingmode = 0\\n\\n self.sample_pressure_high_limit = 100\\n self.sample_pressure_low_limit = 10\\n self.sample_pressure = 0\\n\\n self.error = 0\\n\\n self.buffer_pressure_high = True\",\n \"def __init__(self):\\n self.data = {}\\n self.refresh()\",\n \"def initialize(self):\\n self.voteskips = []\\n self.response = {}\\n self.route = {}\\n self.userlist = []\\n self.poll = []\\n self.media = []\\n self.init = False\\n self.question = None\\n self.jumble = None\\n self.imgur = None\",\n \"def _initialize_data(self):\\n self.reset_count = 0\\n self._idn_no_firmware = \\\"KEPCO,BOP 50-20,E1234,\\\"\\n self._firmware = 2.6\\n self._init_data()\",\n \"def init(self):\",\n \"def init(self):\",\n \"def __init__(self):\\n self.x = {}\\n self.len = 0\\n self.annotations = {}\",\n \"def __init__(self):\\n # Dict of minecraft object in form of \\\"dict[id] = name\\\"\\n self.data_values = dict()\\n self.parser = self.setup_parser()\",\n \"def initialize(self):\\n self.keys = [None] * BUCKET_SIZE\\n self.values = [None] * BUCKET_SIZE\",\n \"def __init__(self, data: dict = {}):\\n pass\",\n \"def initialize(self): \\r\\n pass\",\n \"def __init__(self):\\n self._data = PositionalList() # list of Item instances\",\n \"def __init__(self):\\n self.table = {}\\n self.ls = []\",\n \"def initialize(self):\\r\\n self.bucket_array.initialize()\",\n \"def initialise(self):\\r\\n return\",\n \"def initialise(self):\\r\\n return\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data=None):\\n self.data = data\",\n \"def __init__(self):\\n self._data = set()\",\n \"def __init__(self):\\n self.key_dict = {}\\n self.value_dict = {}\\n self.head, self.last = None, None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7765608","0.7645274","0.7645274","0.7645274","0.7645274","0.7645274","0.7645274","0.7595176","0.75853467","0.7558298","0.7530608","0.7530608","0.7530608","0.7530608","0.7530608","0.74971247","0.74971247","0.7478105","0.7477832","0.7477832","0.7477832","0.7477832","0.7477832","0.7477832","0.7477832","0.7477832","0.744441","0.7426435","0.74157697","0.74143684","0.73898417","0.73898417","0.7389144","0.7387738","0.7383786","0.7324126","0.731669","0.73065454","0.729799","0.7287291","0.7271846","0.725931","0.72522944","0.72522944","0.72522944","0.72494334","0.72494334","0.72494334","0.7243696","0.7239823","0.72368526","0.7208368","0.72016877","0.72016877","0.72016877","0.72016877","0.71985286","0.71985286","0.7195241","0.71885264","0.71857035","0.7176733","0.7160906","0.7159325","0.7149614","0.71474445","0.7135992","0.7128525","0.7123646","0.71142536","0.71142536","0.71142536","0.71142536","0.71109176","0.71011794","0.7099338","0.708543","0.70676583","0.70648897","0.70618606","0.70606047","0.7059818","0.7039291","0.7039291","0.7035077","0.70237756","0.70142615","0.6999669","0.69952625","0.6994778","0.6987417","0.6981039","0.6976582","0.6976582","0.6976431","0.6976431","0.6976431","0.6976431","0.69684774","0.69561034","0.69411176"],"string":"[\n \"0.7765608\",\n \"0.7645274\",\n \"0.7645274\",\n \"0.7645274\",\n \"0.7645274\",\n \"0.7645274\",\n \"0.7645274\",\n \"0.7595176\",\n \"0.75853467\",\n \"0.7558298\",\n \"0.7530608\",\n \"0.7530608\",\n \"0.7530608\",\n \"0.7530608\",\n \"0.7530608\",\n \"0.74971247\",\n \"0.74971247\",\n \"0.7478105\",\n \"0.7477832\",\n \"0.7477832\",\n \"0.7477832\",\n \"0.7477832\",\n \"0.7477832\",\n \"0.7477832\",\n \"0.7477832\",\n \"0.7477832\",\n \"0.744441\",\n \"0.7426435\",\n \"0.74157697\",\n \"0.74143684\",\n \"0.73898417\",\n \"0.73898417\",\n \"0.7389144\",\n \"0.7387738\",\n \"0.7383786\",\n \"0.7324126\",\n \"0.731669\",\n \"0.73065454\",\n \"0.729799\",\n \"0.7287291\",\n \"0.7271846\",\n \"0.725931\",\n \"0.72522944\",\n \"0.72522944\",\n \"0.72522944\",\n \"0.72494334\",\n \"0.72494334\",\n \"0.72494334\",\n \"0.7243696\",\n \"0.7239823\",\n \"0.72368526\",\n \"0.7208368\",\n \"0.72016877\",\n \"0.72016877\",\n \"0.72016877\",\n \"0.72016877\",\n \"0.71985286\",\n \"0.71985286\",\n \"0.7195241\",\n \"0.71885264\",\n \"0.71857035\",\n \"0.7176733\",\n \"0.7160906\",\n \"0.7159325\",\n \"0.7149614\",\n \"0.71474445\",\n \"0.7135992\",\n \"0.7128525\",\n \"0.7123646\",\n \"0.71142536\",\n \"0.71142536\",\n \"0.71142536\",\n \"0.71142536\",\n \"0.71109176\",\n \"0.71011794\",\n \"0.7099338\",\n \"0.708543\",\n \"0.70676583\",\n \"0.70648897\",\n \"0.70618606\",\n \"0.70606047\",\n \"0.7059818\",\n \"0.7039291\",\n \"0.7039291\",\n \"0.7035077\",\n \"0.70237756\",\n \"0.70142615\",\n \"0.6999669\",\n \"0.69952625\",\n \"0.6994778\",\n \"0.6987417\",\n \"0.6981039\",\n \"0.6976582\",\n \"0.6976582\",\n \"0.6976431\",\n \"0.6976431\",\n \"0.6976431\",\n \"0.6976431\",\n \"0.69684774\",\n \"0.69561034\",\n \"0.69411176\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":4488,"cells":{"query":{"kind":"string","value":"Build a dictionary through a list of words"},"document":{"kind":"string","value":"def buildDict(self, words: List[str]) -> None:\n for word in words:\n self.buckets[len(word)].append(word)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def build_dict(word_list):\r\n\r\n # initialize a dictonary\r\n d = dict()\r\n\r\n # iterate through the word_list, mapping sorted letters to word\r\n for i in word_list:\r\n\r\n # key - sorted letters in the word\r\n # how to sort ? --> convert to list, then sort. Finally join the sorted list.\r\n key = ''.join(sorted(list(i)))\r\n\r\n # check if sorted letters avaialble in dict,\r\n # if yes - append the word to the value\r\n # else - put the word as the 0th element of the value list\r\n if key in d:\r\n d[key].append(i)\r\n else:\r\n d[key] = [i]\r\n\r\n return d","def _gen_word_dict(words):\n\n # grab all of them with a single in statement.\n results = lookup_words_by_words(\n (set([self.normalize(w) for w in words] + words)),\n session, Word)\n\n def merge(word):\n if word in results:\n return\n # hopefully these are unique.\n # results[word] = unique_merge(session, Word, word=word)\n results[word] = session.merge(Word(word=word))\n\n for word in words:\n merge(word)\n merge(self.normalize(word))\n\n return results","def buildDict(self, words):\n self.dict = collections.defaultdict(set)\n for word in words:\n for i in xrange(len(word)):\n self.dict[word[:i] + '*' + word[i+1:]].add(word[i])","def buildDict(self, words):\r\n for word in words:\r\n self.trie.addWord(word)","def buildDict(self, words):\n for word in words:\n length = len(word)\n key = \"{}/{}\".format(length, word[0])\n ls = self.origin.get(key, [])\n ls.append(word)\n self.origin[key] = ls","def parallel_word_dict(w_list, st, end):\n import spacy\n w_list = w_list[st:end]\n nlp, out_dict, count = spacy.load('en_core_web_lg'), {}, 0\n for word in w_list:\n word_obj = nlp(word)\n if word_obj.has_vector:\n out_dict[word] = word_obj.vector\n count += 1\n return out_dict","def prepareDictionary(words):\n wordsDictionary = {}\n for word in words:\n # Handle subsequent Occurences\n if (wordsDictionary.get(word.lower(), None) != None):\n # Search and add words by checking their lowercase version\n wordsDictionary[word.lower()] = wordsDictionary.get(word.lower()) + 1\n # Handle first Occurence\n else:\n wordsDictionary[word.lower()] = 1\n return wordsDictionary","def make_freq_dict(word_list):\n\n\tfreq_dict = {}\n\n\tfor word in word_list: #need to slice each tale into a list of words for this to work\n\t\tif word in freq_dict:\n\t\t\tcurrent_val = freq_dict.get(word)\n\t\t\tval = current_val + 1\n\t\t\tfreq_dict[word] = val #made a dictionary of the string (word, frequnecy)\n\t\telse: #if it isn't in the dictionary\n\t\t\tfreq_dict[word] = 1\n\treturn freq_dict","def make_word_dict():\n d = dict()\n fin = open(\"words.txt\")\n for line in fin:\n word = line.strip().lower()\n d[word] = None\n #have to add single letter words to the word list;\n #also, the empty string is considered a word.\n for letter in ['a', 'i', '']:\n d[letter] = letter\n return d","def word_list():\n\n d = {}\n with open('words.txt') as fin:\n for line in fin.readlines():\n word = line.strip().lower()\n d[word] = True\n return d","def __init__(self, words):\n self.d = {}\n for i, w in enumerate(words):\n self.d[w] = self.d.get(w, []) + [i]","def word_list_into_dict(word_list: list) -> dict:\n all_word_dict = {}\n longest_word_dict = {}\n \n for word_index in range(0, len(word_list), 2):\n word = word_list[word_index]\n word_class = word_list[word_index+1][0]\n try:\n all_word_dict[word_class].append(word)\n\n longest_word = longest_word_dict[word_class][0]\n\n if(len(longest_word) < len(word)):\n longest_word_dict[word_class][0] = word\n\n elif(len(longest_word) == len(word)):\n longest_word_dict[word_class][0] = sorted([longest_word, word])[0]\n except:\n all_word_dict[word_class] = [word]\n longest_word_dict[word_class] = [word]\n \n return all_word_dict, longest_word_dict","def dictionary(word_list):\n word_list.append(\"\")\n for i in range(len(word_list)-2):\n prob_dict.setdefault(word_list[i], []).append(word_list[i+1])","def buildDict(self, words):\n for word in words:\n self.word_set.add(word)\n for candidate in self.candidates(word):\n self.neighbors[candidate] += 1","def word_dict():\n fin = open('words.txt')\n w_dict = {}\n for line in fin:\n word = line.strip()\n w_dict[word] = word\n return w_dict","def make_word_dict():\n d = dict()\n for line in open('words.txt'):\n word = line.strip().lower()\n d[word] = None\n\n return d","def dict_list(self):\n word_list = []\n for index in range(len(self.token)-1):\n if self.token[index] not in self.word_dict:\n word_list.append(self.token[index+1]) # Appends words that follow the types\n self.word_dict[self.token[index]] = word_list # Create a dictionary based on types and it's word list\n else:\n if self.token[index] in self.word_dict.keys():\n value = self.word_dict.get(self.token[index]) # gets the list if the type already exists\n value.append(self.token[index+1]) # and append the new word to the list\n word_list = []\n # print(\"self.word_dict\", self.word_dict)","def mkwrddct(inputfile):\n fin = open(inputfile)\n words = dict()\n for line in fin:\n w = line.strip()\n words[w] = w\n return words","def make_trigrams_dict(word_list):\n tris = {}\n for w1, w2, w3 in zip(word_list[:-2], word_list[1:-1], word_list[2:]):\n pair = (w1, w2)\n if pair in tris:\n tris[pair].append(w3)\n else:\n tris[pair] = [w3]\n\n return tris","def database(words):\n\n d={}\n if len(words) < 3:\n return\n \n for i,word in enumerate(words):\n try:\n first,second,third = (words[i], words[i+1], words[i+2])\n except IndexError:\n break\n key = (first,second)\n if key not in d:\n d[key] = []\n d[key].append(third)\n \n return d","def parse_file(input_lst):\n word_dct = {}\n for line in input_lst:\n raw_output = line.split() # these are lists of strings\n for str_ in raw_output: # strings\n str_ = str_.lower()\n str_ = str_.replace(\"-\", \" \")\n str_ = str_.replace(\"?\", \"\")\n str_ = str_.replace(\"!\", \"\")\n str_ = str_.replace(\",\", \"\")\n str_ = str_.replace(\"\\'\", \"\")\n str_ = str_.replace('\\\"', \"\")\n str_ = str_.replace(\".\", \"\")\n if str_ not in word_dct:\n word_dct[str_] = 1\n else:\n word_dct[str_] += 1\n return word_dct","def get_definitions(wlist):\n ddict = {}\n for word in wlist:\n text = get_def_page(word)\n defs = extract_defs(text)\n ddict[word] = defs\n return ddict","def words(phrase):\n\twordlist = phrase.split()\n\tunique_wordlist = []\n\tword_freq = []\n\n \n\twhile wordlist:\n\t\tword_freq.append(wordlist.count(wordlist[0])) #count the instances of a word and add it to the frequencies list\n\t\tunique_wordlist.append(wordlist[0]) #add the word into a unique words list\n\t\twordlist = list(filter((wordlist[0]).__ne__, wordlist)) #remove all other similar words from the wordlist\n\n\n\tn = len(word_freq)\n\toutput = {}\n\n\tfor i in range(n):\n\t\tif unique_wordlist[i].isdigit(): #convert sting digits into int\n\t\t\tunique_wordlist[i] = int(unique_wordlist[i])\n\t\toutput[unique_wordlist[i]] = word_freq[i] #add the unique words with their corresponding frequencies into the output dict\n\t\n\treturn output","def wordListToFreqDict(word_list: list) -> dict:\n word_freq = [word_list.count(p) for p in word_list]\n return dict(list(zip(word_list, word_freq)))","def build_word_dict(self, examples):\n word_dict = TokenDictionary()\n for w in self.load_words(examples):\n word_dict.add(w)\n return word_dict","def analyze_words(self):\n\t\t\n\t\tword_analysis = {}\n\t\tfor word in self.word_list:\n\t\t\tif word not in word_analysis:\n\t\t\t\tacademic = (word in LEMMA_DICT)\n\t\t\t\tlength = len(word)\n\t\t\t\tfrequency = len(self.word_list[word])\n\t\t\t\tstem = word\t\n\t\t\t\tword_location_index = len(self.sentence_index)-1 #first set it as the last index\n\t\t\t\t\n\t\t\t\tfor index, sentence in self.sentence_index.items():\n\t\t\t\t\tif word in sentence.split():#need to be individual words, not parts of a word\n\t\t\t\t\t\tword_location_index = index \n\t\t\t\t\t\tbreak\n\t\t\t\t\tif self.word_list[word][0] in sentence.split():#accounts for words with upper cases\n\t\t\t\t\t\tword_location_index = index\n\t\t\t\t\t\n\t\t\t\t#selection critera\n\t\t\t\tif academic:\n\t\t\t\t\tselection_criteria = 'academic word'\n\t\t\t\telif frequency > 1: \n\t\t\t\t\tselection_criteria = 'high frequency'\n\t\t\t\telse:\n\t\t\t\t\tselection_criteria = 'word length'\n\n\t\t\t\tword_analysis[word] = (academic, length, frequency, stem, word_location_index, selection_criteria)\n\t\t\n\t\tself.word_analysis = word_analysis\n\t\t\n\t\treturn self.word_analysis","def train(s):\n # Creates a new dictionary.\n newDict = {}\n # Separates the string into a list based on the spaces between words.\n wordList = s.split(' ')\n # Loops through the entire list of words. If the word is not in the dictionary, add the current word as a key and add the next word to its list. If the word is in the dictionary, add the next word to the list of the current word. Accounts for the last word in the list by performing the same operation on the first word in the list so that it connects.\n for num in range(len(wordList)):\n if num == len(wordList) - 1:\n if wordList[num] not in newDict:\n newDict[wordList[num]] = []\n newDict[wordList[num]].append(wordList[0])\n else:\n newDict[wordList[num]].append(wordList[0])\n else:\n if wordList[num] not in newDict:\n newDict[wordList[num]] = []\n newDict[wordList[num]].append(wordList[num + 1])\n else:\n newDict[wordList[num]].append(wordList[num + 1])\n\n return newDict","def anagrams(word_lst):\n words_dict = {}\n for word in word_lst:\n characters = ''.join(sorted(list(word)))\n if characters in words_dict:\n words_dict[characters].append(word)\n else:\n words_dict[characters] = [word]\n return words_dict","def update_dictionary_entries(word_list, the_dict):\n\tfor word in word_list:\n\t\tthe_dict[word] = True\n\treturn the_dict","def anagrams(word_list):\n output = dict()\n\n for word in word_list:\n word = word.strip()\n letters = word_to_tuple(word)\n # add letters as key to output dict\n # if not present already\n output[letters] = output.get(letters, [])\n # append word to list at key\n output[letters].append(word)\n\n return output","def dictify(words):\n word_freq = {}\n for word in words:\n if word:\n key = word.lower()\n if key in word_freq:\n word_freq[key] += 1\n else:\n word_freq[key] = 1\n else:\n pass\n return word_freq","def list_to_word_count_dict(self,l):\n to_return = {}\n for i,word in enumerate(l):\n to_return[(word,i)] = 0\n return to_return","def iterate_words(counter, li, all_dict, emotion_dict):\n\n counter += 1\n # iterate through the words in the list\n for word in li:\n # if word not in the dict of all words add it with frequency 1, else increase its frequency by 1\n if word not in all_dict:\n all_dict[word] = 1\n else:\n all_dict[word] += 1\n # if word not in the dict of words with certain emotion add it with frequency 1, else increase its frequency by 1\n if word not in emotion_dict:\n emotion_dict[word] = 1\n else:\n emotion_dict[word] += 1\n\n return counter","def create_freq_dict(sents, lang):\n ix = 0\n freq_dict_all = []\n stop_words = set(stopwords.words(lang))\n\n for sent in sents:\n ix += 1\n freq_dict = {}\n words = word_tokenize(sent)\n\n for word in words:\n word = word.lower()\n if word not in stop_words:\n if word in freq_dict:\n freq_dict[word] += 1\n else:\n freq_dict[word] = 1\n\n temp = {\n 'doc_id': ix,\n 'freq_dict': freq_dict\n }\n\n freq_dict_all.append(temp)\n\n return freq_dict_all","def _create_dictionary(self, document_set):\n words = self._normalize_words(document_set.words)\n unique_words = frozenset(words)\n return dict((word, idx) for idx, word in enumerate(unique_words))","def generate_dictionary(location):\n f = open('../data/wordlist.txt', 'rb')\n words = Counter(re.findall('[a-z]+', f.read().lower().decode()))\n joblib.dump(words, location)","def buildDict(self, dict):\n for word in dict:\n self.add(word)","def wordbag( text, ignore_words = Ignore_words ) :\n iter = (stripword(s) for s in text.lower().split() if stripword(s) not in ignore_words)\n result = {}\n for x in iter :\n if result.has_key(x) :\n result[x] += 1\n else :\n result[x] = 1\n return result","def fill_in_dict():\n # assign a 'data' list from the txt file\n data = open('words.txt')\n # assign an empty 'my_dict' dictionary\n my_dict = dict()\n\n for word in data:\n # fill in dictionarys wit a keys and empty values\n my_dict[word] = ''\n return(my_dict)","def buildDict(self, dict):\n self.all_words = set(dict)\n self.wc_dict = collections.defaultdict(int)\n for w in dict:\n for wc in self.get_wildcards(w):\n self.wc_dict[wc] += 1","def word_freq(self, word_list):\n hist = {}\n for word in word_list:\n hist[word] = hist.get(word, 0) + 1\n return hist","def word_map(text):\n\n # Replace puncation with words\n s = text.replace('.', \" :period:\")\n s = s.replace('\\n', \"\")\n s = s.replace('\"', \" :quote:\")\n s = s.replace(',', \" :comma:\")\n s = s.replace('?', \" :quest:\")\n\n words = sorted(set(s.split(\" \")))\n\n n_to_word = {}\n word_to_n = {}\n\n num = 0\n for word in words:\n n_to_word[num] = word\n word_to_n[word] = num\n num += 1\n\n return words, n_to_word, word_to_n","def create_dictionary(filename):\n file = open(filename, 'r')\n text = file.read()\n file.close()\n words = text.split()\n d = {}\n current_word = '$'\n \n for next_word in words:\n if current_word not in d:\n d[current_word] = [next_word]\n else:\n d[current_word] += [next_word]\n if next_word[-1] == '.' or next_word[-1] == '!' or next_word[-1] == '?':\n current_word = '$'\n else:\n current_word = next_word\n return d","def perform_indexing(self, words_list):\n\n indexer_table = {}\n\n for word in words_list:\n hash_value = self.calculate_weighted_hash(word)\n freq_table = calculate_frequency_table(word)\n\n if hash_value not in indexer_table:\n indexer_table[hash_value] = {}\n indexer_table[hash_value][as_set(freq_table)] = [word]\n else:\n if as_set(freq_table) not in indexer_table[hash_value]:\n indexer_table[hash_value][as_set(freq_table)] = [word]\n else:\n indexer_table[hash_value][as_set(freq_table)].append(word)\n\n return indexer_table","def words(self):\n\t\treturn {c: sorted(l) for (c,l) in sorted(self.dictData.items())}","def makeWords(self):\r\n clean_s = self.cleanString(self.text)\r\n LoW = clean_s.split() \r\n for x in LoW: \r\n if x not in self.words: \r\n self.words[x] = 1\r\n else: \r\n self.words[x] += 1\r\n return self.words","def __init__(self, dictionary):\n self.d = {}\n for word in dictionary:\n abbr = self.getAbbr(word)\n if abbr in self.d:\n self.d[abbr] += word,\n else:\n self.d[abbr] = [word]","def make_mimic_dict(filename):\r\n with open(filename, 'r') as file:\r\n text = file.read().lower().replace(\"'\",'').split()\r\n mimic_dict = {}\r\n prev = ''\r\n for word in text:\r\n if not prev in mimic_dict:\r\n mimic_dict[prev] = [word]\r\n else:\r\n mimic_dict[prev].append(word)\r\n prev = word\r\n return mimic_dict","def _create_dictionary(self, document):\n words = self._normalize_words(document.words)\n unique_words = frozenset(words)\n return dict((word, idx) for idx, word in enumerate(unique_words))","def create_dict(text):\n #On/Off case sensitivity\n text = text.lower() \n\n #handy one liner that splits words apart via whitespace, and \n #removes punctuation. Results in list of words.\n word_list = [s.strip(string.punctuation) for s in text.split()]\n \n d = dict()\n for word in word_list:\n d[word] = d.get(word, 0) +1\n return d","def histogram(word_list):\n assert type(word_list) == list\n\n histogram = {}\n total_words = len(word_list)\n word_frac = 1.0/total_words\n\n for word in word_list:\n if word in histogram: histogram[word] += word_frac\n else: histogram[word] = word_frac\n\n return histogram","def __init__(self, dictionary):\n self.dict = {}\n for word in dictionary:\n abbr = self.gen_abbr(word)\n if abbr not in self.dict:\n word_set = set([word])\n self.dict[abbr] = word_set\n else:\n self.dict[abbr].add(word)","def build_trigram_dict(word_list):\n\n trigram = {}\n for index in range(len(word_list) - 2):\n word1 = word_list[index]\n word2 = word_list[index + 1]\n word3 = word_list[index + 2]\n pair = (word1, word2)\n if pair not in trigram:\n trigram[pair] = [word3]\n else:\n trigram[pair].append(word3)\n return trigram","def create_words_and_values(file_in):\n # Get all key words\n words_in_order = get_lemitized_words_in_order(file_in)\n\n words_and_values = get_keywords_and_values(words_in_order)\n\n return words_and_values","def get_keywords_and_values(words):\n d={}\n triple_keyword_value = 5\n double_keyword_value= 3\n single_keyword_occurance_value = 1\n\n stop_words = set(stopwords.words(\"english\"))\n\n for i in range(0, len(words)-2):\n if words[i] not in stop_words and words[i].isalnum():\n d[words[i]] = d.get(words[i],0.0)+ single_keyword_occurance_value\n if words[i+1] not in stop_words and words[i+1].isalnum():\n d[words[i]+\" \"+words[i+1]] = d.get(words[i]+\" \"+words[i+1],0.0)+double_keyword_value\n if words[i + 2] not in stop_words and words[i + 2].isalnum():\n d[words[i]+\" \"+words[i+1]+\" \"+words[i+2]] = d.get(words[i]+\" \"+words[i+1]+\" \"+words[i+2],0.0)+triple_keyword_value\n\n print(i, len(words))\n\n if words[i+1] not in stop_words and words[i+1].isalnum():\n d[words[i+1]] = d.get(words[i+1],0.0)+ single_keyword_occurance_value\n if words[i+2] not in stop_words and words[i+2].isalnum():\n d[words[i+1]+\" \"+words[i+2]] = d.get(words[i+1]+\" \"+words[i+2],0.0)+double_keyword_value\n if words[i+2] not in stop_words and words[+2].isalnum():\n d[words[i+2]] = d.get(words[i+2],0.0)+ single_keyword_occurance_value\n return d","def build_trigrams(words):\n trigrams = {}\n for i in range(len(words) - 2):\n pair = words[i:i + 2]\n follower = words[i + 2]\n # add tuple type to make it immutable / use append to add more options to the follower selections\n trigrams.setdefault(tuple(pair), []).append(follower)\n #print(trigrams) - for testing\n return trigrams","def get_words(s):\n d = {}\n s = s.lower()\n for word in s.split():\n d[word] = d.get(word,0) + 1\n return d","def frequency(lst):\n\n count = dict()\n for word in lst:\n if word in count:\n count[word] += 1\n else:\n count[word] = 1\n return count","def make_worddict(self):\n\t\tprint(\"Making word dictionary\")\n\t\tword_to_freq = self.make_word_to_freq()\n\t\twords = list(word_to_freq.keys())\n\t\twords.sort() # sort alphabetically first to avoid non-deterministic ordering of words with the same frequency\n\t\twords.sort(key = lambda x:word_to_freq[x], reverse = True)\n\n\t\tfor word in words[:self.FREQCAP-len(self.worddict)]:\n\t\t\tself.worddict[word] = len(self.worddict)\n\t\t\n\t\tprint(\"Word dictionary size:\", len(self.worddict))","def build_word_dict(self, file_type):\n file_name = self.config.parser[file_type + '_dir']\n with open(file_name, 'r') as f:\n for line in f.readlines():\n contents = line.strip().split(' ')\n # an empty line, means seperator for two batch\n # doc id, means a new batch whose `docid` is doc id\n # a word and its tag sepaerated by a blank\n if len(contents) >= 2:\n word, _ = contents[0], contents[1]\n self.word_dict.add_word(word)\n Print(f'word dict from {file_name} is added', 'success')","def lookup_words_by_words(words, session, Word):\n\n return {w.word: w for w in session.query(Word).filter(\n Word.word.in_(words)).all()}","def search_multiple_words(words):\n all_sites = {}\n for word in words:\n for site, freq in search_single_word(word):\n if site not in all_sites: # case 1: haven't included this site\n all_sites[site] = freq # make a new entry for site, freq\n else: # case 2: have included this site\n all_sites[site] += freq # add the frequencies\n L = all_sites.items()\n L.sort(key = lambda pair: pair[1], reverse = True)\n return L","def word_count(phrase):\n words = phrase.split()\n deDupedWords = set(words)\n wordCount = {}\n\n for element in deDupedWords:\n wordCount.update({element: words.count(element)})\n\n return wordCount","def _make_word_dictionary(self,annos):\n # get training annos\n train_annos = self.annos[\"train\"]\n # read tokens\n tokens_list = []\n for ann in train_annos:\n tokens_list += [tk for tk in ann[\"tokens\"]]\n # print results: count tokens and show top-n\n print(\"Top-{} tokens list:\".format(self.cfg.DATASET.SHOW_TOP_VOCAB))\n tokens_count = sorted(Counter(tokens_list).items(), key=lambda x:x[1])\n for tk in tokens_count[-self.cfg.DATASET.SHOW_TOP_VOCAB:]:\n print(\"\\t- {}: {}\".format(tk[0],tk[1]))\n # make wtoi, itow\n wtoi = {}\n wtoi[\"<PAD>\"], wtoi[\"<UNK>\"] = 0, 1\n wtoi[\"<S>\"], wtoi[\"<E>\"] = 2, 3\n for i,(tk,cnt) in enumerate(tokens_count):\n idx = i+4 # idx start at 4\n wtoi[tk] = idx\n itow = {v:k for k,v in wtoi.items()}\n self.cfg.MODEL.QUERY.EMB_IDIM = len(wtoi)\n return wtoi, itow","def build_dict(fname):\n\t\n\twith open(fname) as file:\n\n\t\tword_count_dict = {}\n\n\t\tfor line in file:\n\t\t\tline = line.rstrip()\n\t\t\tline =line.split(' ')\n\t\t\tfor word in line:\n\t\t\t\tword = word.strip('\"!.,?_;():')\n\t\t\t\tword = word.lower()\n\t\t\t\tword_count_dict[word] = word_count_dict.get(word, 0) + 1\n\t\t#return word_count_dict\n\n\t\tfor each in word_count_dict:\n\t\t\tcount = word_count_dict[each]\n\t\t\tprint(each, count)\n\n\t\treturn","def make_word_num_map(words):\n\tword_num_map = dict()\n\tfor word in words:\n\t\tword_num_map[word] = word_num_map.get(word, 0) + 1\n\treturn word_num_map","def __init__(self):\n self.word_dict = collections.defaultdict(list)","def extractWordFeatures(x):\n # BEGIN_YOUR_CODE (around 5 lines of code expected)\n a = Counter(x.split())\n return dict(a)\n # END_YOUR_CODE","def word_frequencies(word_list: TextIO) -> dict:\n words = word_list.read().split(' ')\n amount_of_words = len(set(words))\n frequencies = {}\n for index, word in enumerate(words):\n clean_word = remove_punctuation(word)\n if clean_word not in frequencies:\n frequencies[clean_word] = (index + 1) / amount_of_words\n del frequencies[\"\"]\n return frequencies","def get_word_list_features(word_list, word_features):\n document = ' '.join(word_list)\n words = word_tokenize(document)\n features = {}\n for w in word_features:\n features[w] = (w in words)\n\n return features","def getEmbeddings(model, words):\n\tembeddings = {}\n\tfor word in words:\n\t\tembeddings[word] = model[word]\n\treturn embeddings","def count(words):\n word_count = {}\n num_words = 0\n unique_words = 0\n for word in words:\n num_words += 1\n if word_count.has_key(word):\n word_count[word] += 1\n else:\n word_count[word] = 1\n unique_words += 1\n word_count[\"total\"] = num_words\n word_count[\"unique\"] = unique_words\n return word_count","def word_indexer(word_lst):\n unique_words = list(set(word_lst))\n word_index = {}\n for i in range(len(unique_words)):\n word_index[unique_words[i].lower()] = i + 4\n word_index['<PAD>'] = 0\n word_index['<START>'] = 1\n word_index['<UNK>'] = 2\n word_index['<UNUSED>'] = 3\n return word_index","def create_dictionary(file_dir):\r\n\tword_list = []\r\n\tfile_list = read_files(file_dir, \"lab\") # step 7\r\n\tfor file in file_list:\r\n\t\twith open(file, 'r') as f:\r\n\t\t\ttext = f.read()\r\n\t\tword_list = store_to_dictionary(text, word_list) # step 8cii\r\n\tmake_dictionary_file(file_dir, word_list) # step 9\r","def generate_vocab_dict(vocab):\n v_dict = {}\n for word in vocab:\n if len(word) in v_dict:\n v_dict[len(word)].append(word)\n else:\n v_dict[len(word)] = [word]\n return v_dict","def create_word_list(self):\n return set(self.split(self.title)+self.split(self.conditions)+self.split(self.interventions))","def create_model_owc(text: str) -> Dict[str, Set[str]]:\n dict_so_far = {}\n list_of_words = str.split(text)\n\n\n for x in range(0, len(list_of_words)):\n \"\"\"\n check if the word is followed by a period and add it to the follow list if it is, then remove the period to \n check if the word is followed by something else\n \"\"\"\n if list_of_words[x][-1] == '.':\n list_of_words[x] = list_of_words[x][0:-1]\n update_follow_set(dict_so_far, list_of_words[x], '.')\n\n else:\n update_follow_set(dict_so_far, list_of_words[x], list_of_words[x + 1].rstrip('.'))\n return dict_so_far","def count_words_in_sentence_list(sentence_list):\n\ttotal_dict = dict()\n\tfor _ in sentence_list:\n\t\tcount = count_word_in_each_sentence(_)\n\t\tfor key, value in count.items():\n\t\t\tif total_dict.get(key):\n\t\t\t\ttotal_dict[key] += value\n\t\t\telse:\n\t\t\t\ttotal_dict[key] = value\n\treturn total_dict","def word_frequency_dict(tokens):\n\n\tfdist = FreqDist(tokens) \t\t\t\t\t\t# fdist.keys() fdist.values()\n\treturn dict(fdist)","def read_dictionary():\n with open(FILE, 'r') as f:\n for line in f:\n words_lst = line.split()\n for word in words_lst:\n dict_list.append(word)","def add_words_from_dict(self, kind: str, fn: str, words: Any) -> None:\n for word in words or []:\n self.words.add(word)\n self.words.add(word.lower())","def anagrams(words):\n\n anagrams = {}\n for word in words:\n wordAsList = \"\".join(sorted(list(word))).strip()\n if anagrams.has_key(wordAsList):\n anagrams[wordAsList].append(word)\n else:\n anagrams[wordAsList] = [word]\n\n return anagrams","def buildDict(self, dict):\n for word in dict:\n self.s.add(word)\n self.length_set = set([len(word) for word in dict])","def dictionary(cleaned_data,threshold):\n news = []\n for date in cleaned_data:\n for headlines in cleaned_data[date]:\n news.append(headlines)\n\n word_freq = nltk.FreqDist(itertools.chain(*news))\n id_to_word = ['<pad>'] + [word for word, cnt in word_freq.items() if cnt >= threshold] + ['<unk>']\n word_to_id = {word:idx for idx, word in enumerate(id_to_word)}\n \n return id_to_word, word_to_id","def word_frequency(words):\r\n frequency = {}\r\n for w in words:\r\n frequency[w] = frequency.get(w, 0) + 1\r\n return frequency","def to_words(content,words):\n return ''.join(words[x] for x in content)","def test_dictionary_create_repeat():\n tokens = [['testing'], ['testing', 'testing', 'testing'], ['make', 'tokens']]\n dictionary = edurate_gensim.dictionary_create(tokens)\n corp = [dictionary.doc2bow(token) for token in tokens]\n assert corp == [[(0, 1)], [(0, 3)], [(1, 1), (2, 1)]]","def _vector_mapping(self) -> dict:\n words = set()\n for file in os.listdir(self.processed_path):\n doc_path = f\"{self.processed_path}/{file}\"\n with open(doc_path, 'r') as f:\n text_words = f.readline().split()\n words = words.union(set(text_words))\n words = list(words)\n words.sort()\n\n return dict(zip(words, range(len(words))))","def build_dict(min_word_freq=0, train_dir=\"\", test_dir=\"\"):\n word_freq = collections.defaultdict(int)\n files = os.listdir(train_dir)\n for fi in files:\n with open(os.path.join(train_dir, fi), \"r\") as f:\n word_freq = word_count(f, word_freq)\n files = os.listdir(test_dir)\n for fi in files:\n with open(os.path.join(test_dir, fi), \"r\") as f:\n word_freq = word_count(f, word_freq)\n\n word_freq = [x for x in six.iteritems(word_freq) if x[1] > min_word_freq]\n word_freq_sorted = sorted(word_freq, key=lambda x: (-x[1], x[0]))\n words, _ = list(zip(*word_freq_sorted))\n word_idx = dict(list(zip(words, six.moves.range(len(words)))))\n return word_idx","def make_bag_words(document_tokenized):\n bag_words = dict()\n for token in document_tokenized:\n if token in bag_words.keys():\n bag_words[token] += 1\n else:\n bag_words[token] = 1\n return bag_words","def create_word_map(tokenized_descriptions_file_path, word_dictionary_output_path):\n if os.path.exists(word_dictionary_output_path):\n print(\"Word map already exists in workspace. Will be reused.\")\n return\n\n print(\"Word map not found. Generating....\")\n\n words_list = []\n words_to_id = {}\n\n with open(tokenized_descriptions_file_path, 'r') as file:\n for line in file:\n tokens = line.strip().split(\",\")\n words_list.extend(tokens[1:])\n\n # remove duplicate words\n words_list = list(set(words_list))\n\n # sorting the words\n words_list = sorted(words_list)\n for i in range(len(words_list)):\n words_to_id[words_list[i]] = i\n\n with open(word_dictionary_output_path, 'w') as f:\n [f.write('{0},{1}'.format(key, value) + \"\\n\") for key, value in words_to_id.items()]","def bow(tokens):\n return dict(collections.Counter(re.findall(r'\\w+', \" \".join(tokens))))","def prep_dict(word):\n counts = {}\n for l in word.lower():\n if l!=\" \":\n counts[l] = counts.get(l,0) + 1\n return counts","def get_count_words(novel, words):\n dic_word_counts = {}\n for word in words:\n dic_word_counts[word] = novel.get_count_of_word(word)\n return dic_word_counts","def get_features(words):\n features = {}\n for word in [i for i in words.split() if i not in stopwords.words('english')]:\n features['contains_%s' % word.lower()] = True\n return features","def count(words):\n\n values = []\n \n # dictionary whose keys are words and values number of occurrences\n D = {}\n\n for word in words:\n # if word is already in dict add 1 to the count\n try : D[word] +=1\n # otherwise add entrye to dict\n except : D[word] = 1\n\n values += [D[word]]\n\n return values","def build_trigrams(words):\n trigrams = {}\n for i in range(len(words) - 2): # why -2 ?\n pair = ()\n pair = words[i:i + 2]\n key = \" \"\n key = key.join(pair)\n follower = []\n follower.append(words[i + 2])\n follower = words[i + 2]\n if key in trigrams.keys():\n existing_value = trigrams[key]\n list(existing_value)\n existing_value.append(follower)\n trigrams[key] = existing_value\n else:\n trigrams.update({key: list(follower.split(\" \"))})\n return trigrams","def word_counter(list_) -> list:\n from operator import itemgetter\n _dict = dict()\n for word in list_:\n if word in _dict:\n _dict[word] = _dict[word] + 1\n else:\n _dict[word] = 1\n return sorted(_dict.items(), key=itemgetter(1), reverse=True)","def clsWordCounts(wd_dict, wd_list, cl):\n\n # set up counter object for words in passed word list\n word_counts = Counter(wd_list)\n\n # for each term in counter object\n for term in word_counts:\n\n # if already in dictionary add to the count\n if term in wd_dict[cl]:\n\n wd_dict[cl][term] += word_counts[term]\n\n # else add to the dictionary\n else:\n\n wd_dict[cl][term] = word_counts[term]\n\n return wd_dict","def analyze_word(s):\n\n a = {}\n a['word'] = s\n a['n_letters'] = len(s)\n a['n_vowels'] = count_vowels(s)\n \n return a"],"string":"[\n \"def build_dict(word_list):\\r\\n\\r\\n # initialize a dictonary\\r\\n d = dict()\\r\\n\\r\\n # iterate through the word_list, mapping sorted letters to word\\r\\n for i in word_list:\\r\\n\\r\\n # key - sorted letters in the word\\r\\n # how to sort ? --> convert to list, then sort. Finally join the sorted list.\\r\\n key = ''.join(sorted(list(i)))\\r\\n\\r\\n # check if sorted letters avaialble in dict,\\r\\n # if yes - append the word to the value\\r\\n # else - put the word as the 0th element of the value list\\r\\n if key in d:\\r\\n d[key].append(i)\\r\\n else:\\r\\n d[key] = [i]\\r\\n\\r\\n return d\",\n \"def _gen_word_dict(words):\\n\\n # grab all of them with a single in statement.\\n results = lookup_words_by_words(\\n (set([self.normalize(w) for w in words] + words)),\\n session, Word)\\n\\n def merge(word):\\n if word in results:\\n return\\n # hopefully these are unique.\\n # results[word] = unique_merge(session, Word, word=word)\\n results[word] = session.merge(Word(word=word))\\n\\n for word in words:\\n merge(word)\\n merge(self.normalize(word))\\n\\n return results\",\n \"def buildDict(self, words):\\n self.dict = collections.defaultdict(set)\\n for word in words:\\n for i in xrange(len(word)):\\n self.dict[word[:i] + '*' + word[i+1:]].add(word[i])\",\n \"def buildDict(self, words):\\r\\n for word in words:\\r\\n self.trie.addWord(word)\",\n \"def buildDict(self, words):\\n for word in words:\\n length = len(word)\\n key = \\\"{}/{}\\\".format(length, word[0])\\n ls = self.origin.get(key, [])\\n ls.append(word)\\n self.origin[key] = ls\",\n \"def parallel_word_dict(w_list, st, end):\\n import spacy\\n w_list = w_list[st:end]\\n nlp, out_dict, count = spacy.load('en_core_web_lg'), {}, 0\\n for word in w_list:\\n word_obj = nlp(word)\\n if word_obj.has_vector:\\n out_dict[word] = word_obj.vector\\n count += 1\\n return out_dict\",\n \"def prepareDictionary(words):\\n wordsDictionary = {}\\n for word in words:\\n # Handle subsequent Occurences\\n if (wordsDictionary.get(word.lower(), None) != None):\\n # Search and add words by checking their lowercase version\\n wordsDictionary[word.lower()] = wordsDictionary.get(word.lower()) + 1\\n # Handle first Occurence\\n else:\\n wordsDictionary[word.lower()] = 1\\n return wordsDictionary\",\n \"def make_freq_dict(word_list):\\n\\n\\tfreq_dict = {}\\n\\n\\tfor word in word_list: #need to slice each tale into a list of words for this to work\\n\\t\\tif word in freq_dict:\\n\\t\\t\\tcurrent_val = freq_dict.get(word)\\n\\t\\t\\tval = current_val + 1\\n\\t\\t\\tfreq_dict[word] = val #made a dictionary of the string (word, frequnecy)\\n\\t\\telse: #if it isn't in the dictionary\\n\\t\\t\\tfreq_dict[word] = 1\\n\\treturn freq_dict\",\n \"def make_word_dict():\\n d = dict()\\n fin = open(\\\"words.txt\\\")\\n for line in fin:\\n word = line.strip().lower()\\n d[word] = None\\n #have to add single letter words to the word list;\\n #also, the empty string is considered a word.\\n for letter in ['a', 'i', '']:\\n d[letter] = letter\\n return d\",\n \"def word_list():\\n\\n d = {}\\n with open('words.txt') as fin:\\n for line in fin.readlines():\\n word = line.strip().lower()\\n d[word] = True\\n return d\",\n \"def __init__(self, words):\\n self.d = {}\\n for i, w in enumerate(words):\\n self.d[w] = self.d.get(w, []) + [i]\",\n \"def word_list_into_dict(word_list: list) -> dict:\\n all_word_dict = {}\\n longest_word_dict = {}\\n \\n for word_index in range(0, len(word_list), 2):\\n word = word_list[word_index]\\n word_class = word_list[word_index+1][0]\\n try:\\n all_word_dict[word_class].append(word)\\n\\n longest_word = longest_word_dict[word_class][0]\\n\\n if(len(longest_word) < len(word)):\\n longest_word_dict[word_class][0] = word\\n\\n elif(len(longest_word) == len(word)):\\n longest_word_dict[word_class][0] = sorted([longest_word, word])[0]\\n except:\\n all_word_dict[word_class] = [word]\\n longest_word_dict[word_class] = [word]\\n \\n return all_word_dict, longest_word_dict\",\n \"def dictionary(word_list):\\n word_list.append(\\\"\\\")\\n for i in range(len(word_list)-2):\\n prob_dict.setdefault(word_list[i], []).append(word_list[i+1])\",\n \"def buildDict(self, words):\\n for word in words:\\n self.word_set.add(word)\\n for candidate in self.candidates(word):\\n self.neighbors[candidate] += 1\",\n \"def word_dict():\\n fin = open('words.txt')\\n w_dict = {}\\n for line in fin:\\n word = line.strip()\\n w_dict[word] = word\\n return w_dict\",\n \"def make_word_dict():\\n d = dict()\\n for line in open('words.txt'):\\n word = line.strip().lower()\\n d[word] = None\\n\\n return d\",\n \"def dict_list(self):\\n word_list = []\\n for index in range(len(self.token)-1):\\n if self.token[index] not in self.word_dict:\\n word_list.append(self.token[index+1]) # Appends words that follow the types\\n self.word_dict[self.token[index]] = word_list # Create a dictionary based on types and it's word list\\n else:\\n if self.token[index] in self.word_dict.keys():\\n value = self.word_dict.get(self.token[index]) # gets the list if the type already exists\\n value.append(self.token[index+1]) # and append the new word to the list\\n word_list = []\\n # print(\\\"self.word_dict\\\", self.word_dict)\",\n \"def mkwrddct(inputfile):\\n fin = open(inputfile)\\n words = dict()\\n for line in fin:\\n w = line.strip()\\n words[w] = w\\n return words\",\n \"def make_trigrams_dict(word_list):\\n tris = {}\\n for w1, w2, w3 in zip(word_list[:-2], word_list[1:-1], word_list[2:]):\\n pair = (w1, w2)\\n if pair in tris:\\n tris[pair].append(w3)\\n else:\\n tris[pair] = [w3]\\n\\n return tris\",\n \"def database(words):\\n\\n d={}\\n if len(words) < 3:\\n return\\n \\n for i,word in enumerate(words):\\n try:\\n first,second,third = (words[i], words[i+1], words[i+2])\\n except IndexError:\\n break\\n key = (first,second)\\n if key not in d:\\n d[key] = []\\n d[key].append(third)\\n \\n return d\",\n \"def parse_file(input_lst):\\n word_dct = {}\\n for line in input_lst:\\n raw_output = line.split() # these are lists of strings\\n for str_ in raw_output: # strings\\n str_ = str_.lower()\\n str_ = str_.replace(\\\"-\\\", \\\" \\\")\\n str_ = str_.replace(\\\"?\\\", \\\"\\\")\\n str_ = str_.replace(\\\"!\\\", \\\"\\\")\\n str_ = str_.replace(\\\",\\\", \\\"\\\")\\n str_ = str_.replace(\\\"\\\\'\\\", \\\"\\\")\\n str_ = str_.replace('\\\\\\\"', \\\"\\\")\\n str_ = str_.replace(\\\".\\\", \\\"\\\")\\n if str_ not in word_dct:\\n word_dct[str_] = 1\\n else:\\n word_dct[str_] += 1\\n return word_dct\",\n \"def get_definitions(wlist):\\n ddict = {}\\n for word in wlist:\\n text = get_def_page(word)\\n defs = extract_defs(text)\\n ddict[word] = defs\\n return ddict\",\n \"def words(phrase):\\n\\twordlist = phrase.split()\\n\\tunique_wordlist = []\\n\\tword_freq = []\\n\\n \\n\\twhile wordlist:\\n\\t\\tword_freq.append(wordlist.count(wordlist[0])) #count the instances of a word and add it to the frequencies list\\n\\t\\tunique_wordlist.append(wordlist[0]) #add the word into a unique words list\\n\\t\\twordlist = list(filter((wordlist[0]).__ne__, wordlist)) #remove all other similar words from the wordlist\\n\\n\\n\\tn = len(word_freq)\\n\\toutput = {}\\n\\n\\tfor i in range(n):\\n\\t\\tif unique_wordlist[i].isdigit(): #convert sting digits into int\\n\\t\\t\\tunique_wordlist[i] = int(unique_wordlist[i])\\n\\t\\toutput[unique_wordlist[i]] = word_freq[i] #add the unique words with their corresponding frequencies into the output dict\\n\\t\\n\\treturn output\",\n \"def wordListToFreqDict(word_list: list) -> dict:\\n word_freq = [word_list.count(p) for p in word_list]\\n return dict(list(zip(word_list, word_freq)))\",\n \"def build_word_dict(self, examples):\\n word_dict = TokenDictionary()\\n for w in self.load_words(examples):\\n word_dict.add(w)\\n return word_dict\",\n \"def analyze_words(self):\\n\\t\\t\\n\\t\\tword_analysis = {}\\n\\t\\tfor word in self.word_list:\\n\\t\\t\\tif word not in word_analysis:\\n\\t\\t\\t\\tacademic = (word in LEMMA_DICT)\\n\\t\\t\\t\\tlength = len(word)\\n\\t\\t\\t\\tfrequency = len(self.word_list[word])\\n\\t\\t\\t\\tstem = word\\t\\n\\t\\t\\t\\tword_location_index = len(self.sentence_index)-1 #first set it as the last index\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tfor index, sentence in self.sentence_index.items():\\n\\t\\t\\t\\t\\tif word in sentence.split():#need to be individual words, not parts of a word\\n\\t\\t\\t\\t\\t\\tword_location_index = index \\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\tif self.word_list[word][0] in sentence.split():#accounts for words with upper cases\\n\\t\\t\\t\\t\\t\\tword_location_index = index\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t#selection critera\\n\\t\\t\\t\\tif academic:\\n\\t\\t\\t\\t\\tselection_criteria = 'academic word'\\n\\t\\t\\t\\telif frequency > 1: \\n\\t\\t\\t\\t\\tselection_criteria = 'high frequency'\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tselection_criteria = 'word length'\\n\\n\\t\\t\\t\\tword_analysis[word] = (academic, length, frequency, stem, word_location_index, selection_criteria)\\n\\t\\t\\n\\t\\tself.word_analysis = word_analysis\\n\\t\\t\\n\\t\\treturn self.word_analysis\",\n \"def train(s):\\n # Creates a new dictionary.\\n newDict = {}\\n # Separates the string into a list based on the spaces between words.\\n wordList = s.split(' ')\\n # Loops through the entire list of words. If the word is not in the dictionary, add the current word as a key and add the next word to its list. If the word is in the dictionary, add the next word to the list of the current word. Accounts for the last word in the list by performing the same operation on the first word in the list so that it connects.\\n for num in range(len(wordList)):\\n if num == len(wordList) - 1:\\n if wordList[num] not in newDict:\\n newDict[wordList[num]] = []\\n newDict[wordList[num]].append(wordList[0])\\n else:\\n newDict[wordList[num]].append(wordList[0])\\n else:\\n if wordList[num] not in newDict:\\n newDict[wordList[num]] = []\\n newDict[wordList[num]].append(wordList[num + 1])\\n else:\\n newDict[wordList[num]].append(wordList[num + 1])\\n\\n return newDict\",\n \"def anagrams(word_lst):\\n words_dict = {}\\n for word in word_lst:\\n characters = ''.join(sorted(list(word)))\\n if characters in words_dict:\\n words_dict[characters].append(word)\\n else:\\n words_dict[characters] = [word]\\n return words_dict\",\n \"def update_dictionary_entries(word_list, the_dict):\\n\\tfor word in word_list:\\n\\t\\tthe_dict[word] = True\\n\\treturn the_dict\",\n \"def anagrams(word_list):\\n output = dict()\\n\\n for word in word_list:\\n word = word.strip()\\n letters = word_to_tuple(word)\\n # add letters as key to output dict\\n # if not present already\\n output[letters] = output.get(letters, [])\\n # append word to list at key\\n output[letters].append(word)\\n\\n return output\",\n \"def dictify(words):\\n word_freq = {}\\n for word in words:\\n if word:\\n key = word.lower()\\n if key in word_freq:\\n word_freq[key] += 1\\n else:\\n word_freq[key] = 1\\n else:\\n pass\\n return word_freq\",\n \"def list_to_word_count_dict(self,l):\\n to_return = {}\\n for i,word in enumerate(l):\\n to_return[(word,i)] = 0\\n return to_return\",\n \"def iterate_words(counter, li, all_dict, emotion_dict):\\n\\n counter += 1\\n # iterate through the words in the list\\n for word in li:\\n # if word not in the dict of all words add it with frequency 1, else increase its frequency by 1\\n if word not in all_dict:\\n all_dict[word] = 1\\n else:\\n all_dict[word] += 1\\n # if word not in the dict of words with certain emotion add it with frequency 1, else increase its frequency by 1\\n if word not in emotion_dict:\\n emotion_dict[word] = 1\\n else:\\n emotion_dict[word] += 1\\n\\n return counter\",\n \"def create_freq_dict(sents, lang):\\n ix = 0\\n freq_dict_all = []\\n stop_words = set(stopwords.words(lang))\\n\\n for sent in sents:\\n ix += 1\\n freq_dict = {}\\n words = word_tokenize(sent)\\n\\n for word in words:\\n word = word.lower()\\n if word not in stop_words:\\n if word in freq_dict:\\n freq_dict[word] += 1\\n else:\\n freq_dict[word] = 1\\n\\n temp = {\\n 'doc_id': ix,\\n 'freq_dict': freq_dict\\n }\\n\\n freq_dict_all.append(temp)\\n\\n return freq_dict_all\",\n \"def _create_dictionary(self, document_set):\\n words = self._normalize_words(document_set.words)\\n unique_words = frozenset(words)\\n return dict((word, idx) for idx, word in enumerate(unique_words))\",\n \"def generate_dictionary(location):\\n f = open('../data/wordlist.txt', 'rb')\\n words = Counter(re.findall('[a-z]+', f.read().lower().decode()))\\n joblib.dump(words, location)\",\n \"def buildDict(self, dict):\\n for word in dict:\\n self.add(word)\",\n \"def wordbag( text, ignore_words = Ignore_words ) :\\n iter = (stripword(s) for s in text.lower().split() if stripword(s) not in ignore_words)\\n result = {}\\n for x in iter :\\n if result.has_key(x) :\\n result[x] += 1\\n else :\\n result[x] = 1\\n return result\",\n \"def fill_in_dict():\\n # assign a 'data' list from the txt file\\n data = open('words.txt')\\n # assign an empty 'my_dict' dictionary\\n my_dict = dict()\\n\\n for word in data:\\n # fill in dictionarys wit a keys and empty values\\n my_dict[word] = ''\\n return(my_dict)\",\n \"def buildDict(self, dict):\\n self.all_words = set(dict)\\n self.wc_dict = collections.defaultdict(int)\\n for w in dict:\\n for wc in self.get_wildcards(w):\\n self.wc_dict[wc] += 1\",\n \"def word_freq(self, word_list):\\n hist = {}\\n for word in word_list:\\n hist[word] = hist.get(word, 0) + 1\\n return hist\",\n \"def word_map(text):\\n\\n # Replace puncation with words\\n s = text.replace('.', \\\" :period:\\\")\\n s = s.replace('\\\\n', \\\"\\\")\\n s = s.replace('\\\"', \\\" :quote:\\\")\\n s = s.replace(',', \\\" :comma:\\\")\\n s = s.replace('?', \\\" :quest:\\\")\\n\\n words = sorted(set(s.split(\\\" \\\")))\\n\\n n_to_word = {}\\n word_to_n = {}\\n\\n num = 0\\n for word in words:\\n n_to_word[num] = word\\n word_to_n[word] = num\\n num += 1\\n\\n return words, n_to_word, word_to_n\",\n \"def create_dictionary(filename):\\n file = open(filename, 'r')\\n text = file.read()\\n file.close()\\n words = text.split()\\n d = {}\\n current_word = '$'\\n \\n for next_word in words:\\n if current_word not in d:\\n d[current_word] = [next_word]\\n else:\\n d[current_word] += [next_word]\\n if next_word[-1] == '.' or next_word[-1] == '!' or next_word[-1] == '?':\\n current_word = '$'\\n else:\\n current_word = next_word\\n return d\",\n \"def perform_indexing(self, words_list):\\n\\n indexer_table = {}\\n\\n for word in words_list:\\n hash_value = self.calculate_weighted_hash(word)\\n freq_table = calculate_frequency_table(word)\\n\\n if hash_value not in indexer_table:\\n indexer_table[hash_value] = {}\\n indexer_table[hash_value][as_set(freq_table)] = [word]\\n else:\\n if as_set(freq_table) not in indexer_table[hash_value]:\\n indexer_table[hash_value][as_set(freq_table)] = [word]\\n else:\\n indexer_table[hash_value][as_set(freq_table)].append(word)\\n\\n return indexer_table\",\n \"def words(self):\\n\\t\\treturn {c: sorted(l) for (c,l) in sorted(self.dictData.items())}\",\n \"def makeWords(self):\\r\\n clean_s = self.cleanString(self.text)\\r\\n LoW = clean_s.split() \\r\\n for x in LoW: \\r\\n if x not in self.words: \\r\\n self.words[x] = 1\\r\\n else: \\r\\n self.words[x] += 1\\r\\n return self.words\",\n \"def __init__(self, dictionary):\\n self.d = {}\\n for word in dictionary:\\n abbr = self.getAbbr(word)\\n if abbr in self.d:\\n self.d[abbr] += word,\\n else:\\n self.d[abbr] = [word]\",\n \"def make_mimic_dict(filename):\\r\\n with open(filename, 'r') as file:\\r\\n text = file.read().lower().replace(\\\"'\\\",'').split()\\r\\n mimic_dict = {}\\r\\n prev = ''\\r\\n for word in text:\\r\\n if not prev in mimic_dict:\\r\\n mimic_dict[prev] = [word]\\r\\n else:\\r\\n mimic_dict[prev].append(word)\\r\\n prev = word\\r\\n return mimic_dict\",\n \"def _create_dictionary(self, document):\\n words = self._normalize_words(document.words)\\n unique_words = frozenset(words)\\n return dict((word, idx) for idx, word in enumerate(unique_words))\",\n \"def create_dict(text):\\n #On/Off case sensitivity\\n text = text.lower() \\n\\n #handy one liner that splits words apart via whitespace, and \\n #removes punctuation. Results in list of words.\\n word_list = [s.strip(string.punctuation) for s in text.split()]\\n \\n d = dict()\\n for word in word_list:\\n d[word] = d.get(word, 0) +1\\n return d\",\n \"def histogram(word_list):\\n assert type(word_list) == list\\n\\n histogram = {}\\n total_words = len(word_list)\\n word_frac = 1.0/total_words\\n\\n for word in word_list:\\n if word in histogram: histogram[word] += word_frac\\n else: histogram[word] = word_frac\\n\\n return histogram\",\n \"def __init__(self, dictionary):\\n self.dict = {}\\n for word in dictionary:\\n abbr = self.gen_abbr(word)\\n if abbr not in self.dict:\\n word_set = set([word])\\n self.dict[abbr] = word_set\\n else:\\n self.dict[abbr].add(word)\",\n \"def build_trigram_dict(word_list):\\n\\n trigram = {}\\n for index in range(len(word_list) - 2):\\n word1 = word_list[index]\\n word2 = word_list[index + 1]\\n word3 = word_list[index + 2]\\n pair = (word1, word2)\\n if pair not in trigram:\\n trigram[pair] = [word3]\\n else:\\n trigram[pair].append(word3)\\n return trigram\",\n \"def create_words_and_values(file_in):\\n # Get all key words\\n words_in_order = get_lemitized_words_in_order(file_in)\\n\\n words_and_values = get_keywords_and_values(words_in_order)\\n\\n return words_and_values\",\n \"def get_keywords_and_values(words):\\n d={}\\n triple_keyword_value = 5\\n double_keyword_value= 3\\n single_keyword_occurance_value = 1\\n\\n stop_words = set(stopwords.words(\\\"english\\\"))\\n\\n for i in range(0, len(words)-2):\\n if words[i] not in stop_words and words[i].isalnum():\\n d[words[i]] = d.get(words[i],0.0)+ single_keyword_occurance_value\\n if words[i+1] not in stop_words and words[i+1].isalnum():\\n d[words[i]+\\\" \\\"+words[i+1]] = d.get(words[i]+\\\" \\\"+words[i+1],0.0)+double_keyword_value\\n if words[i + 2] not in stop_words and words[i + 2].isalnum():\\n d[words[i]+\\\" \\\"+words[i+1]+\\\" \\\"+words[i+2]] = d.get(words[i]+\\\" \\\"+words[i+1]+\\\" \\\"+words[i+2],0.0)+triple_keyword_value\\n\\n print(i, len(words))\\n\\n if words[i+1] not in stop_words and words[i+1].isalnum():\\n d[words[i+1]] = d.get(words[i+1],0.0)+ single_keyword_occurance_value\\n if words[i+2] not in stop_words and words[i+2].isalnum():\\n d[words[i+1]+\\\" \\\"+words[i+2]] = d.get(words[i+1]+\\\" \\\"+words[i+2],0.0)+double_keyword_value\\n if words[i+2] not in stop_words and words[+2].isalnum():\\n d[words[i+2]] = d.get(words[i+2],0.0)+ single_keyword_occurance_value\\n return d\",\n \"def build_trigrams(words):\\n trigrams = {}\\n for i in range(len(words) - 2):\\n pair = words[i:i + 2]\\n follower = words[i + 2]\\n # add tuple type to make it immutable / use append to add more options to the follower selections\\n trigrams.setdefault(tuple(pair), []).append(follower)\\n #print(trigrams) - for testing\\n return trigrams\",\n \"def get_words(s):\\n d = {}\\n s = s.lower()\\n for word in s.split():\\n d[word] = d.get(word,0) + 1\\n return d\",\n \"def frequency(lst):\\n\\n count = dict()\\n for word in lst:\\n if word in count:\\n count[word] += 1\\n else:\\n count[word] = 1\\n return count\",\n \"def make_worddict(self):\\n\\t\\tprint(\\\"Making word dictionary\\\")\\n\\t\\tword_to_freq = self.make_word_to_freq()\\n\\t\\twords = list(word_to_freq.keys())\\n\\t\\twords.sort() # sort alphabetically first to avoid non-deterministic ordering of words with the same frequency\\n\\t\\twords.sort(key = lambda x:word_to_freq[x], reverse = True)\\n\\n\\t\\tfor word in words[:self.FREQCAP-len(self.worddict)]:\\n\\t\\t\\tself.worddict[word] = len(self.worddict)\\n\\t\\t\\n\\t\\tprint(\\\"Word dictionary size:\\\", len(self.worddict))\",\n \"def build_word_dict(self, file_type):\\n file_name = self.config.parser[file_type + '_dir']\\n with open(file_name, 'r') as f:\\n for line in f.readlines():\\n contents = line.strip().split(' ')\\n # an empty line, means seperator for two batch\\n # doc id, means a new batch whose `docid` is doc id\\n # a word and its tag sepaerated by a blank\\n if len(contents) >= 2:\\n word, _ = contents[0], contents[1]\\n self.word_dict.add_word(word)\\n Print(f'word dict from {file_name} is added', 'success')\",\n \"def lookup_words_by_words(words, session, Word):\\n\\n return {w.word: w for w in session.query(Word).filter(\\n Word.word.in_(words)).all()}\",\n \"def search_multiple_words(words):\\n all_sites = {}\\n for word in words:\\n for site, freq in search_single_word(word):\\n if site not in all_sites: # case 1: haven't included this site\\n all_sites[site] = freq # make a new entry for site, freq\\n else: # case 2: have included this site\\n all_sites[site] += freq # add the frequencies\\n L = all_sites.items()\\n L.sort(key = lambda pair: pair[1], reverse = True)\\n return L\",\n \"def word_count(phrase):\\n words = phrase.split()\\n deDupedWords = set(words)\\n wordCount = {}\\n\\n for element in deDupedWords:\\n wordCount.update({element: words.count(element)})\\n\\n return wordCount\",\n \"def _make_word_dictionary(self,annos):\\n # get training annos\\n train_annos = self.annos[\\\"train\\\"]\\n # read tokens\\n tokens_list = []\\n for ann in train_annos:\\n tokens_list += [tk for tk in ann[\\\"tokens\\\"]]\\n # print results: count tokens and show top-n\\n print(\\\"Top-{} tokens list:\\\".format(self.cfg.DATASET.SHOW_TOP_VOCAB))\\n tokens_count = sorted(Counter(tokens_list).items(), key=lambda x:x[1])\\n for tk in tokens_count[-self.cfg.DATASET.SHOW_TOP_VOCAB:]:\\n print(\\\"\\\\t- {}: {}\\\".format(tk[0],tk[1]))\\n # make wtoi, itow\\n wtoi = {}\\n wtoi[\\\"<PAD>\\\"], wtoi[\\\"<UNK>\\\"] = 0, 1\\n wtoi[\\\"<S>\\\"], wtoi[\\\"<E>\\\"] = 2, 3\\n for i,(tk,cnt) in enumerate(tokens_count):\\n idx = i+4 # idx start at 4\\n wtoi[tk] = idx\\n itow = {v:k for k,v in wtoi.items()}\\n self.cfg.MODEL.QUERY.EMB_IDIM = len(wtoi)\\n return wtoi, itow\",\n \"def build_dict(fname):\\n\\t\\n\\twith open(fname) as file:\\n\\n\\t\\tword_count_dict = {}\\n\\n\\t\\tfor line in file:\\n\\t\\t\\tline = line.rstrip()\\n\\t\\t\\tline =line.split(' ')\\n\\t\\t\\tfor word in line:\\n\\t\\t\\t\\tword = word.strip('\\\"!.,?_;():')\\n\\t\\t\\t\\tword = word.lower()\\n\\t\\t\\t\\tword_count_dict[word] = word_count_dict.get(word, 0) + 1\\n\\t\\t#return word_count_dict\\n\\n\\t\\tfor each in word_count_dict:\\n\\t\\t\\tcount = word_count_dict[each]\\n\\t\\t\\tprint(each, count)\\n\\n\\t\\treturn\",\n \"def make_word_num_map(words):\\n\\tword_num_map = dict()\\n\\tfor word in words:\\n\\t\\tword_num_map[word] = word_num_map.get(word, 0) + 1\\n\\treturn word_num_map\",\n \"def __init__(self):\\n self.word_dict = collections.defaultdict(list)\",\n \"def extractWordFeatures(x):\\n # BEGIN_YOUR_CODE (around 5 lines of code expected)\\n a = Counter(x.split())\\n return dict(a)\\n # END_YOUR_CODE\",\n \"def word_frequencies(word_list: TextIO) -> dict:\\n words = word_list.read().split(' ')\\n amount_of_words = len(set(words))\\n frequencies = {}\\n for index, word in enumerate(words):\\n clean_word = remove_punctuation(word)\\n if clean_word not in frequencies:\\n frequencies[clean_word] = (index + 1) / amount_of_words\\n del frequencies[\\\"\\\"]\\n return frequencies\",\n \"def get_word_list_features(word_list, word_features):\\n document = ' '.join(word_list)\\n words = word_tokenize(document)\\n features = {}\\n for w in word_features:\\n features[w] = (w in words)\\n\\n return features\",\n \"def getEmbeddings(model, words):\\n\\tembeddings = {}\\n\\tfor word in words:\\n\\t\\tembeddings[word] = model[word]\\n\\treturn embeddings\",\n \"def count(words):\\n word_count = {}\\n num_words = 0\\n unique_words = 0\\n for word in words:\\n num_words += 1\\n if word_count.has_key(word):\\n word_count[word] += 1\\n else:\\n word_count[word] = 1\\n unique_words += 1\\n word_count[\\\"total\\\"] = num_words\\n word_count[\\\"unique\\\"] = unique_words\\n return word_count\",\n \"def word_indexer(word_lst):\\n unique_words = list(set(word_lst))\\n word_index = {}\\n for i in range(len(unique_words)):\\n word_index[unique_words[i].lower()] = i + 4\\n word_index['<PAD>'] = 0\\n word_index['<START>'] = 1\\n word_index['<UNK>'] = 2\\n word_index['<UNUSED>'] = 3\\n return word_index\",\n \"def create_dictionary(file_dir):\\r\\n\\tword_list = []\\r\\n\\tfile_list = read_files(file_dir, \\\"lab\\\") # step 7\\r\\n\\tfor file in file_list:\\r\\n\\t\\twith open(file, 'r') as f:\\r\\n\\t\\t\\ttext = f.read()\\r\\n\\t\\tword_list = store_to_dictionary(text, word_list) # step 8cii\\r\\n\\tmake_dictionary_file(file_dir, word_list) # step 9\\r\",\n \"def generate_vocab_dict(vocab):\\n v_dict = {}\\n for word in vocab:\\n if len(word) in v_dict:\\n v_dict[len(word)].append(word)\\n else:\\n v_dict[len(word)] = [word]\\n return v_dict\",\n \"def create_word_list(self):\\n return set(self.split(self.title)+self.split(self.conditions)+self.split(self.interventions))\",\n \"def create_model_owc(text: str) -> Dict[str, Set[str]]:\\n dict_so_far = {}\\n list_of_words = str.split(text)\\n\\n\\n for x in range(0, len(list_of_words)):\\n \\\"\\\"\\\"\\n check if the word is followed by a period and add it to the follow list if it is, then remove the period to \\n check if the word is followed by something else\\n \\\"\\\"\\\"\\n if list_of_words[x][-1] == '.':\\n list_of_words[x] = list_of_words[x][0:-1]\\n update_follow_set(dict_so_far, list_of_words[x], '.')\\n\\n else:\\n update_follow_set(dict_so_far, list_of_words[x], list_of_words[x + 1].rstrip('.'))\\n return dict_so_far\",\n \"def count_words_in_sentence_list(sentence_list):\\n\\ttotal_dict = dict()\\n\\tfor _ in sentence_list:\\n\\t\\tcount = count_word_in_each_sentence(_)\\n\\t\\tfor key, value in count.items():\\n\\t\\t\\tif total_dict.get(key):\\n\\t\\t\\t\\ttotal_dict[key] += value\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttotal_dict[key] = value\\n\\treturn total_dict\",\n \"def word_frequency_dict(tokens):\\n\\n\\tfdist = FreqDist(tokens) \\t\\t\\t\\t\\t\\t# fdist.keys() fdist.values()\\n\\treturn dict(fdist)\",\n \"def read_dictionary():\\n with open(FILE, 'r') as f:\\n for line in f:\\n words_lst = line.split()\\n for word in words_lst:\\n dict_list.append(word)\",\n \"def add_words_from_dict(self, kind: str, fn: str, words: Any) -> None:\\n for word in words or []:\\n self.words.add(word)\\n self.words.add(word.lower())\",\n \"def anagrams(words):\\n\\n anagrams = {}\\n for word in words:\\n wordAsList = \\\"\\\".join(sorted(list(word))).strip()\\n if anagrams.has_key(wordAsList):\\n anagrams[wordAsList].append(word)\\n else:\\n anagrams[wordAsList] = [word]\\n\\n return anagrams\",\n \"def buildDict(self, dict):\\n for word in dict:\\n self.s.add(word)\\n self.length_set = set([len(word) for word in dict])\",\n \"def dictionary(cleaned_data,threshold):\\n news = []\\n for date in cleaned_data:\\n for headlines in cleaned_data[date]:\\n news.append(headlines)\\n\\n word_freq = nltk.FreqDist(itertools.chain(*news))\\n id_to_word = ['<pad>'] + [word for word, cnt in word_freq.items() if cnt >= threshold] + ['<unk>']\\n word_to_id = {word:idx for idx, word in enumerate(id_to_word)}\\n \\n return id_to_word, word_to_id\",\n \"def word_frequency(words):\\r\\n frequency = {}\\r\\n for w in words:\\r\\n frequency[w] = frequency.get(w, 0) + 1\\r\\n return frequency\",\n \"def to_words(content,words):\\n return ''.join(words[x] for x in content)\",\n \"def test_dictionary_create_repeat():\\n tokens = [['testing'], ['testing', 'testing', 'testing'], ['make', 'tokens']]\\n dictionary = edurate_gensim.dictionary_create(tokens)\\n corp = [dictionary.doc2bow(token) for token in tokens]\\n assert corp == [[(0, 1)], [(0, 3)], [(1, 1), (2, 1)]]\",\n \"def _vector_mapping(self) -> dict:\\n words = set()\\n for file in os.listdir(self.processed_path):\\n doc_path = f\\\"{self.processed_path}/{file}\\\"\\n with open(doc_path, 'r') as f:\\n text_words = f.readline().split()\\n words = words.union(set(text_words))\\n words = list(words)\\n words.sort()\\n\\n return dict(zip(words, range(len(words))))\",\n \"def build_dict(min_word_freq=0, train_dir=\\\"\\\", test_dir=\\\"\\\"):\\n word_freq = collections.defaultdict(int)\\n files = os.listdir(train_dir)\\n for fi in files:\\n with open(os.path.join(train_dir, fi), \\\"r\\\") as f:\\n word_freq = word_count(f, word_freq)\\n files = os.listdir(test_dir)\\n for fi in files:\\n with open(os.path.join(test_dir, fi), \\\"r\\\") as f:\\n word_freq = word_count(f, word_freq)\\n\\n word_freq = [x for x in six.iteritems(word_freq) if x[1] > min_word_freq]\\n word_freq_sorted = sorted(word_freq, key=lambda x: (-x[1], x[0]))\\n words, _ = list(zip(*word_freq_sorted))\\n word_idx = dict(list(zip(words, six.moves.range(len(words)))))\\n return word_idx\",\n \"def make_bag_words(document_tokenized):\\n bag_words = dict()\\n for token in document_tokenized:\\n if token in bag_words.keys():\\n bag_words[token] += 1\\n else:\\n bag_words[token] = 1\\n return bag_words\",\n \"def create_word_map(tokenized_descriptions_file_path, word_dictionary_output_path):\\n if os.path.exists(word_dictionary_output_path):\\n print(\\\"Word map already exists in workspace. Will be reused.\\\")\\n return\\n\\n print(\\\"Word map not found. Generating....\\\")\\n\\n words_list = []\\n words_to_id = {}\\n\\n with open(tokenized_descriptions_file_path, 'r') as file:\\n for line in file:\\n tokens = line.strip().split(\\\",\\\")\\n words_list.extend(tokens[1:])\\n\\n # remove duplicate words\\n words_list = list(set(words_list))\\n\\n # sorting the words\\n words_list = sorted(words_list)\\n for i in range(len(words_list)):\\n words_to_id[words_list[i]] = i\\n\\n with open(word_dictionary_output_path, 'w') as f:\\n [f.write('{0},{1}'.format(key, value) + \\\"\\\\n\\\") for key, value in words_to_id.items()]\",\n \"def bow(tokens):\\n return dict(collections.Counter(re.findall(r'\\\\w+', \\\" \\\".join(tokens))))\",\n \"def prep_dict(word):\\n counts = {}\\n for l in word.lower():\\n if l!=\\\" \\\":\\n counts[l] = counts.get(l,0) + 1\\n return counts\",\n \"def get_count_words(novel, words):\\n dic_word_counts = {}\\n for word in words:\\n dic_word_counts[word] = novel.get_count_of_word(word)\\n return dic_word_counts\",\n \"def get_features(words):\\n features = {}\\n for word in [i for i in words.split() if i not in stopwords.words('english')]:\\n features['contains_%s' % word.lower()] = True\\n return features\",\n \"def count(words):\\n\\n values = []\\n \\n # dictionary whose keys are words and values number of occurrences\\n D = {}\\n\\n for word in words:\\n # if word is already in dict add 1 to the count\\n try : D[word] +=1\\n # otherwise add entrye to dict\\n except : D[word] = 1\\n\\n values += [D[word]]\\n\\n return values\",\n \"def build_trigrams(words):\\n trigrams = {}\\n for i in range(len(words) - 2): # why -2 ?\\n pair = ()\\n pair = words[i:i + 2]\\n key = \\\" \\\"\\n key = key.join(pair)\\n follower = []\\n follower.append(words[i + 2])\\n follower = words[i + 2]\\n if key in trigrams.keys():\\n existing_value = trigrams[key]\\n list(existing_value)\\n existing_value.append(follower)\\n trigrams[key] = existing_value\\n else:\\n trigrams.update({key: list(follower.split(\\\" \\\"))})\\n return trigrams\",\n \"def word_counter(list_) -> list:\\n from operator import itemgetter\\n _dict = dict()\\n for word in list_:\\n if word in _dict:\\n _dict[word] = _dict[word] + 1\\n else:\\n _dict[word] = 1\\n return sorted(_dict.items(), key=itemgetter(1), reverse=True)\",\n \"def clsWordCounts(wd_dict, wd_list, cl):\\n\\n # set up counter object for words in passed word list\\n word_counts = Counter(wd_list)\\n\\n # for each term in counter object\\n for term in word_counts:\\n\\n # if already in dictionary add to the count\\n if term in wd_dict[cl]:\\n\\n wd_dict[cl][term] += word_counts[term]\\n\\n # else add to the dictionary\\n else:\\n\\n wd_dict[cl][term] = word_counts[term]\\n\\n return wd_dict\",\n \"def analyze_word(s):\\n\\n a = {}\\n a['word'] = s\\n a['n_letters'] = len(s)\\n a['n_vowels'] = count_vowels(s)\\n \\n return a\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7771935","0.7714796","0.76650697","0.75896126","0.7402118","0.7371921","0.7257023","0.724838","0.72190464","0.71511894","0.7121465","0.70906883","0.70329714","0.69910663","0.6939837","0.6926235","0.69013107","0.68620795","0.68157786","0.6809816","0.6763535","0.6733835","0.66926974","0.6672779","0.6632391","0.6610456","0.65891856","0.6588288","0.6573257","0.6570725","0.65617216","0.6555818","0.65151054","0.6510993","0.6505765","0.6496117","0.6495923","0.64873344","0.64711845","0.6463316","0.646033","0.644894","0.64170086","0.6415676","0.64130116","0.6403004","0.63776106","0.63559026","0.6348519","0.6340014","0.63326","0.63074356","0.62916356","0.6282301","0.6274789","0.6257068","0.62545043","0.6248074","0.6244352","0.62415487","0.62377536","0.6234071","0.6231643","0.6228746","0.6220464","0.61950105","0.61757195","0.6175457","0.6174988","0.61698747","0.6156159","0.6156113","0.61491454","0.6146453","0.61455715","0.61360997","0.6124478","0.61233276","0.6106081","0.61056834","0.60981476","0.6092355","0.6091201","0.6087671","0.6076661","0.607472","0.60695285","0.6059188","0.6058311","0.6057396","0.6047712","0.60415244","0.6040443","0.60358363","0.6035677","0.6022717","0.6018232","0.6008099","0.60052556","0.5999378"],"string":"[\n \"0.7771935\",\n \"0.7714796\",\n \"0.76650697\",\n \"0.75896126\",\n \"0.7402118\",\n \"0.7371921\",\n \"0.7257023\",\n \"0.724838\",\n \"0.72190464\",\n \"0.71511894\",\n \"0.7121465\",\n \"0.70906883\",\n \"0.70329714\",\n \"0.69910663\",\n \"0.6939837\",\n \"0.6926235\",\n \"0.69013107\",\n \"0.68620795\",\n \"0.68157786\",\n \"0.6809816\",\n \"0.6763535\",\n \"0.6733835\",\n \"0.66926974\",\n \"0.6672779\",\n \"0.6632391\",\n \"0.6610456\",\n \"0.65891856\",\n \"0.6588288\",\n \"0.6573257\",\n \"0.6570725\",\n \"0.65617216\",\n \"0.6555818\",\n \"0.65151054\",\n \"0.6510993\",\n \"0.6505765\",\n \"0.6496117\",\n \"0.6495923\",\n \"0.64873344\",\n \"0.64711845\",\n \"0.6463316\",\n \"0.646033\",\n \"0.644894\",\n \"0.64170086\",\n \"0.6415676\",\n \"0.64130116\",\n \"0.6403004\",\n \"0.63776106\",\n \"0.63559026\",\n \"0.6348519\",\n \"0.6340014\",\n \"0.63326\",\n \"0.63074356\",\n \"0.62916356\",\n \"0.6282301\",\n \"0.6274789\",\n \"0.6257068\",\n \"0.62545043\",\n \"0.6248074\",\n \"0.6244352\",\n \"0.62415487\",\n \"0.62377536\",\n \"0.6234071\",\n \"0.6231643\",\n \"0.6228746\",\n \"0.6220464\",\n \"0.61950105\",\n \"0.61757195\",\n \"0.6175457\",\n \"0.6174988\",\n \"0.61698747\",\n \"0.6156159\",\n \"0.6156113\",\n \"0.61491454\",\n \"0.6146453\",\n \"0.61455715\",\n \"0.61360997\",\n \"0.6124478\",\n \"0.61233276\",\n \"0.6106081\",\n \"0.61056834\",\n \"0.60981476\",\n \"0.6092355\",\n \"0.6091201\",\n \"0.6087671\",\n \"0.6076661\",\n \"0.607472\",\n \"0.60695285\",\n \"0.6059188\",\n \"0.6058311\",\n \"0.6057396\",\n \"0.6047712\",\n \"0.60415244\",\n \"0.6040443\",\n \"0.60358363\",\n \"0.6035677\",\n \"0.6022717\",\n \"0.6018232\",\n \"0.6008099\",\n \"0.60052556\",\n \"0.5999378\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75077"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":4489,"cells":{"query":{"kind":"string","value":"Returns if there is any word in the trie that equals to the given word after modifying exactly one character"},"document":{"kind":"string","value":"def search(self, word: str) -> bool:\n\n # # for candidate in self.buckets[len(word)]:\n # # for a, b in zip(word, candidate):\n # # result = any(sum(a!=b))\n return any(sum(a!=b for a, b in zip(word, candidate)) == 1\n for candidate in self.buckets[len(word)])\n #\n # for candidate in self.buckets[len(word)]:\n # sum = 0\n # for a, b in zip(word, candidate):\n # sum += (a!=b)\n # if sum == 0:\n # return True\n # return False"},"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 is_word(trie, string: str) -> bool:\n return any(w == string for w in trie)","def search(self, word):\n curr = self.trie\n for i, ch in enumerate(word):\n curr = curr.get(ch, {})\n if curr:\n continue\n else:\n break\n \n if i==len(word)-1 and '\\0' in curr:\n ret = True\n else:\n ret = False\n\n return ret","def has_word(self, word)->bool:\n if len(word) == 1:\n chars = word + GNode.CHAR_EOW\n else:\n chars = word[0] + GNode.CHAR_REV + word[1:] + GNode.CHAR_EOW\n cursor = self.root\n for c in chars.lower():\n if c not in cursor.children:\n return False\n else:\n cursor = cursor.children[c]\n return True","def search(self, word):\n length = len(word)\n if length == 1:\n for letter in string.ascii_lowercase:\n key = \"{}/{}\".format(1, letter)\n if key in self.origin and letter != word:\n return True\n return False\n\n key = \"{}/{}\".format(len(word), word[0])\n ls = self.origin.get(key, [])\n if len(ls) == 0:\n return False\n\n for origin in ls:\n if self.only_modify_one_char(word, origin):\n return True\n return False","def in_trie(self, trie, word):\n current_dict = trie\n for letter in word:\n if letter in current_dict:\n current_dict = current_dict[letter]\n else:\n return False\n else:\n if '_end_' in current_dict:\n return current_dict['_end_']\n else:\n return False\n return False","def search(self, word):\n level = self.trie\n for c in word:\n if c in level:\n level = level[c]\n else:\n return False\n return self.end in level","def search_full_word(self, word):\n node = self.root\n for i in range(len(word)):\n current_letter = word[i]\n current_index = self.to_index(current_letter)\n if node.children[current_index] and node.is_word:\n node = node.children[current_index]\n else:\n return False\n # save last node after a search\n self.saved_node = node\n return True","def search(self, word):\n if not word:\n return False\n if word[0] not in self.trie:\n return False\n cur = self.trie[word[0]]\n for char in word[1:]:\n if char not in cur.nexts:\n return False\n cur = cur.nexts[char]\n return (cur and cur.isTerm) == True","def search(self, word: str) -> bool:\n tries = [self.trie]\n for c in word:\n if c != '.':\n tries = [\n trie[c] for trie in tries if c in trie\n ]\n else:\n tries = [\n v for trie in tries for v in trie.values() if v\n ]\n\n if not tries:\n return False\n\n return any(None in trie for trie in tries)","def search(self, word):\r\n t = self.trie\r\n for w in word: \r\n if w not in t: \r\n return False\r\n t = t[w]\r\n if '#' in t:\r\n return True\r\n return False","def search(self, word: str) -> bool:\n node = self.root\n for char in word:\n if char not in node:\n return False\n node = node[char]\n return self.end_of_word in node","def search(self, word: str) -> bool:\r\n nroot=self.root\r\n for j in word:\r\n \r\n # index=ord(j)-ord('a')\r\n if j not in nroot.children:\r\n return False\r\n nroot=nroot.children[j] \r\n return nroot.endofword","def search(self, word):\n for i in xrange(len(word)):\n w = word[:i] + '*' + word[i+1:]\n if w in self.dict and (len(self.dict[w]) > 1 or word[i] not in self.dict[w]): return True \n return False","def search(self, word: str) -> bool:\n cur = self.root\n for letter in word:\n if letter not in cur:\n return False\n cur = cur[letter]\n if \"isWord\" not in cur:\n return False\n return True","def search(self, word: str) -> bool:\n temp=self.root\n \n for char in word:\n if(not temp.children[ord(char)-ord('a')]):\n return False\n temp=temp.children[ord(char)-ord('a')]\n \n if(temp and temp.endOfWord==True):\n return True\n \n return False","def check_present_and_add(self, word):\n\n current_node = self.root_node\n is_new_word = False\n\n # iterate through trie adding missing notes\n for char in word:\n if char not in current_node:\n is_new_word = True\n current_node[char] = {}\n current_node = current_node[char]\n \n # mark end of word so that words that are prefixes of present words are not\n # returned - i.e. each word must have an explicit \"End of Word\" marker\n if \"End of Word\" not in current_node:\n is_new_word = True\n current_node[\"End on Word\"] = {}\n\n return is_new_word","def check_word(self, word):\n\n if not self.words:\n return None\n word = ''.join(word)\n return next((True for w in self.words if w == word), False)","def search(self, word: str) -> bool:\n current = self.root\n for letter in word: \n current = current.children.get(letter)\n if not current:\n return False\n return current.is_word","def checkWord(self, word):\n\t\treturn self.root.checkString(u' ' + word);","def search(self, word: str) -> bool:\n return self.trie.search(word + '#', self.trie.trie)","def search(self, word):\n node = self.root\n for char in word:\n if char in node.dict:\n node = node.dict[char]\n else:\n return False\n if node.end:\n return True\n return False","def search(self, word: str, root: dict = None) -> bool:\n word += '0'\n return self._search(word, self.trie)","def search(self, word: str) -> bool:\n node = self.root\n for c in word:\n if c not in node:\n return False\n node = node[c]\n return self.end in node","def checkWord(word):\r\n check = word in cachedWordList\r\n if check:\r\n print(word + \" spelt correctly\")\r\n else:\r\n print(word + \" not found in dictionary\")\r\n return check","def contains_word(root, input_word):\n\n cNode = root\n\n for char in list(input_word):\n found_match = False\n for node in cNode.nodes:\n if node.char == char:\n found_match = True\n cNode = node\n break\n\n if not found_match:\n print(\"Exited in for loop\")\n return False\n\n return cNode.is_word","def search(self, word):\n current = self.root\n for i in word:\n if current.hash_map.get(i) is None:\n return False\n current = current.hash_map.get(i)\n if current.num != 0:\n return True\n return False","def search(self, word: str) -> bool:\r\n node=self.root\r\n for c in word:\r\n if c not in node:\r\n return False\r\n else:\r\n node = node[c]\r\n if self.end_of_words in node:\r\n return True\r\n else:\r\n return False","def search(self, word: str) -> bool:\n #start from the root\n node = self.root\n for char in word:\n if char in node.child:\n node = node.child.get(char)\n else:\n return False\n return node.isWord","def search(self, word):\n #edge case\n if word == \"\": \n return True if self._dict.children[26] != None else False\n\n cur = self._dict\n for c in word:\n ind = ord(c) - 97\n if cur.children[ind] == None:\n return False\n cur = cur.children[ind]\n\n return True if cur.isleaf == True else False","def search(self, word):\n current = self.root\n for letter in word:\n current = current.children.get(letter)\n \n if current is None:\n return False\n return current.is_word","def search(self, word: str) -> bool:\n node = self\n for c in word:\n node = node.d.get(c)\n if not node:\n return False\n return node.end","def search(self, word: str) -> bool:\n n = self.root\n for l in word[0:-1]:\n cn = n.get_child_with_val(l)\n if cn == None or cn.eow:\n return False\n n = cn\n\n last_node = n.get_eow_child_with_val(word[-1])\n if last_node == None:\n return False\n return True","def search(self, word):\n if len(word) not in self.length_set:\n return False\n for i in self.mutate(word):\n if i in self.s:\n return True\n return False","def search(self, word: str) -> bool:\n curr = self.root\n for c in word:\n if not c in curr.adj:\n return False\n curr = curr.adj[c]\n return curr.isWord","def search(self, word: str) -> bool:\n node = self.root\n for c in word:\n if c not in node.children:\n return False\n node = node.children[c]\n return True","def search(self, word: str) -> bool:\n def DFS(i, word, trie):\n if i == len(word):\n return '#' in trie\n # c == '.'\n # c in trie\n c = word[i]\n res = False\n if c == '.':\n for cc in trie.keys():\n if cc != '#':\n res = res or DFS(i + 1, word, trie[cc])\n elif word[i] in trie:\n res = res or DFS(i + 1, word, trie[c])\n return res\n\n return DFS(0, word, self.trie)","def search(self, word: str) -> bool:\n node = self.root\n for w in word:\n node = node.children.get(w)\n if not node:\n return False\n return node.end","def search(self, word: str) -> bool:\n curr = self.root\n for ch in word:\n curr = curr.children.get(ch)\n if curr is None:\n return False\n return curr.is_word","def search(self, word: str) -> bool:\n def recur(word, trie):\n if not word:\n if '$' in trie:\n return True\n return False\n if word[0] in trie:\n return recur(word[1:], trie[word[0]])\n elif word[0] == '.':\n to_return = False\n for char in trie.keys():\n to_return = to_return or recur(word[1:], trie[char])\n return to_return\n return False\n return recur(word, self.trie)","def search(self, word):\n curNode = self.root\n for c in word:\n if not c in curNode:\n return False\n curNode = curNode[c]\n \n # Doesn't end here\n if not self.end in curNode:\n return False\n \n return True","def search(self, word: str) -> bool:\n if len(word) == 0:\n return True\n idx = ord(word[0]) - ord('a')\n if not self.children[idx]:\n return False\n if len(word) == 1:\n return self.children[idx].tail # switch for only once\n\n return self.children[idx].search(word[1:])","def search(self, word):\n pointer = self.tries\n for i in range(len(word)):\n ascii = ord(word[i]) - ord('a')\n if pointer[ascii] == None:\n return False\n pointer = pointer[ascii]\n if word in pointer[26:]:\n return True\n else:\n return False","def search(self, word: str) -> bool:\n curr_chars = self.chars\n for c in list(word):\n if c not in curr_chars:\n return False\n curr_chars = curr_chars[c]\n return self.end_of_word in curr_chars","def search(self, word):\n node = self.root\n for letter in word:\n if letter not in node.children:\n return False\n node = node.children[letter]\n return node.endOfWord","def search(self, word: str) -> bool:\n parent = self.root\n for char in word:\n if char not in parent.children:\n return False\n parent = parent.children[char]\n return parent.endhere","def search(self, word):\n now = self.tree\n for i in word:\n if i in now:\n now = now[i]\n else:\n return False\n return True if 'end' in now else False","def search(self, word: str) -> bool:\n node = self.root\n for char in word:\n if char not in node:\n return False\n node = node[char]\n if \"#\" not in node:\n return False\n return True","def search_word(self, word):\n current = self.root\n for letter in word:\n \n current = current.get_child(letter) # node is not next letter in word\n\n if not current: # if node is null, return False\n return False\n \n if not current.get_end():\n return False\n return True","def search(self, word: str) -> bool:\n\n temp = self.start\n\n for i in range(len(word)):\n \n if temp.children[ord(word[i]) - ord('a')] is None:\n return False\n temp = temp.children[ord(word[i])-ord('a')]\n if i+1 == len(word) and temp.end == True:\n return True\n\n return False","def search(self, word):\n node = self.root\n for c in word:\n if c in node.children:\n node = node.children[c]\n else:\n return False\n return node.word_end","def search(self, word: str) -> bool:\n current = self.root\n for letter in word:\n if letter not in current.children:\n return False\n current = current.children[letter]\n return current.has_end","def search(self, word):\n node = self.root\n for letter in word:\n if letter not in node.children:\n return False\n node = node.children[letter]\n return node.word","def search(self, word):\n curr = [self.trie]\n\n for c in word:\n next_curr = []\n if c != '.':\n for n in curr:\n if c in n.children:\n next_curr.append(n.children[c])\n else:\n for n in curr:\n next_curr.extend(n.children.values())\n curr = next_curr\n if not curr:\n return False\n\n return any([n.is_term for n in curr])","def search(self, word: str) -> bool:\n currnode=self.root\n\n for ch in word:\n node=currnode.children.get(ch)\n if node is None:\n return False\n\n return currNode.isWordEnd","def check_word(words, word):\r\n if word in words:\r\n return True\r\n else:\r\n return False","def has_word(self, word):\n return word in self.word_set","def search(self, word):\n if len(word) == 0:\n return False\n todo = [self]\n for idx, letter in enumerate(word):\n if len(todo) == 0:\n break\n new_todo = []\n if letter == '.':\n for node in todo:\n new_todo += list(node.kids.values())\n else:\n for node in todo:\n if letter in node.kids:\n new_todo.append(node.kids[letter])\n if idx == len(word) - 1 and node.kids[letter].isWord:\n return True\n todo = new_todo\n if len(todo) > 0 and word[-1] == '.':\n for ele in todo:\n if ele.isWord:\n return True\n\n return False","def search(self, word):\n node = self.search_prefix(word)\n return node is not None and '#' in node and node['#'] == 1","def search(self, word):\n currNode = self.root\n\n for c in word:\n if c not in currNode.children:\n return False\n currNode = currNode.children[c]\n return currNode.isEnd","def search(self, word: str) -> bool:\n node = self.head\n for c in word:\n if c not in node.next:\n return False\n node = node.next[c]\n return node.valid","def search(self, word):\n lenw = len(word)\n if lenw not in self.bag: return False\n return any([self.equal_to(word, item) for item in self.bag[lenw]])","def search(self, word) -> bool:\n return self.match(self.root, 0, word)","def search(self, word: str):\n node = self.root\n for letter in word:\n if letter in node.child:\n node = node.child[letter]\n else:\n return False\n return node.is_leaf","def check_match(self, word_found,word): \r\n self.count = 0\r\n for char in self.word_found:\r\n if char != self.word[self.count]:\r\n return False\r\n self.count +=1\r\n #print(self.count)\r\n \r\n return True","def search(self, word: str) -> bool:\n node = self._traverse(word)\n return node.word if node else False","def search(self, word: 'str') -> 'bool':\n p = self.root\n for ch in word:\n if ch in p:\n p = p[ch]\n else:\n return False\n\n if '#' in p:\n return True\n else:\n return False","def check_word(self, word):\n first_letter, rest = word[0], word[1:]\n\n for possible_start in self._find_letter(first_letter):\n if self._check_word(possible_start, rest):\n return True\n\n return False","def search(self, word):\n def r_search(word,i,d):\n if len(word) <= i:\n return True\n \n if d == 0:\n return False\n \n return (word[i] in d) and r_search(word,i+1,d[word[i]])\n \n tri = self.root.d\n if len(word) == 0: \n return True\n \n if len(tri) == 0:\n return False\n \n return r_search(word + '$',0,tri)","def check_word(word):\r\n if word in word_master:\r\n valid = True\r\n else:\r\n valid = False\r\n return valid","def word_check(word):\n word1 = word[1:]\n if word1 not in word_dict: return False\n if not homophones (word, word1): return False\n \n \n word2 = word[0] + word[2:]\n if word2 not in word_dict: return False\n if not homophones(word, word2): return False\n\n return True","def search(self, word: str) -> bool:\n node = self.find(word)\n return node and node.is_word","def search(self, word: str) -> bool:\n return self.search_recursive(self.root, word, 0)","def search(self, word: str) -> bool:\n tmp = self.root\n for i in range(len(word)): \n if word[i] == \".\":\n valid = False\n for nxt in tmp.seq.keys():\n valid = valid or self.search(word[:i] + nxt + word[i+1:])\n \n if valid:\n return True\n return False\n \n if word[i] not in tmp.seq:\n return False \n tmp = tmp.seq[word[i]]\n \n return tmp.value == word","def search(self, word):\n node = self.root\n for i in word:\n if i not in node.children:\n return False\n node = node.children[i]\n return node.word","def search(self, word):\n length = len(word)\n if length not in self.dic:\n return False\n else:\n candidateList = self.dic[length]\n for candidate in candidateList:\n for i in xrange(length):\n if candidate[i] != word[i]:\n if candidate[i+1:] == word[i+1:]:\n return True\n else:\n break\n return False","def chars_match (found, word):\n index = 0\n for i in found:\n if (i != word[index]):\n return False\n index += 1\n return True","def check_word(self, word):\n word = word.lower().strip()\n return not word or word in self.dictionary","def valid_word(self, word):\n\n word = ''.join(word)\n return next((w for w in self.words if w == word), None)","def contains(self, word: Iterable[Terminal]) -> bool:\n return self._get_final_state(word) is not None","def test_contains_returns_false_when_word_mismatches(full_trie):\n assert full_trie.contains(\"hello\") is False","def search(self, word):\n for wc in self.get_wildcards(word):\n # Don't forget word not in self.all_words\n if wc in self.wc_dict and (self.wc_dict[wc] > 1 or word not in self.all_words) :\n return True\n return False","def test_contains_returns_true_when_word_in_trie(full_trie):\n assert full_trie.contains(\"hey\") is True","def search(self, word):\n end_node = self.__find_node(word)\n if end_node and end_node.is_word:\n return True\n return False","def check(self,word):\n if self.pre:\n def sub_word(chars):\n if re.match('^'+chars+'.*',word):\n return word[len(chars):]\n else:\n return None\n else:\n def sub_word(chars):\n if re.match('^.*'+chars+'$',word):\n return word[:-len(chars)]\n else:\n return None\n\n if word == '':\n return self\n for chars in self.branches.keys():\n res = sub_word(chars)\n if res:\n return self.branches[chars].check(res)\n elif res == '':\n return self.branches[chars]\n return None","def search(self, word):\n for candidate in self.candidates(word):\n if self.neighbors[candidate] > 1:\n return True\n elif self.neighbors[candidate] == 1 and word not in self.word_set:\n return True\n return False","def trifeca(word):\n if not word:\n return False\n\n for i in range(len(word)-1):\n if word[i]==word[i+1]:\n if len(word[i:])>=6:\n if word[i+2:i+6:2]==word[i+3:i+7:2]:\n return True \n return False","def existRecu(self, board, word, row, col) -> bool:\n if len(word) == 0:\n return True\n elif row < 0 or row == len(board): # Edge breaking\n return False\n elif col < 0 or col == len(board[0]): # Edge breaking\n return False\n elif board[row][col] is None:\n return False\n elif board[row][col] != word[0]: # miss-matching\n return False\n else:\n board[row][col] = None\n return self.existRecu(deepcopy(board), word[1:], row - 1, col) or \\\n self.existRecu(deepcopy(board), word[1:], row + 1, col) or \\\n self.existRecu(deepcopy(board), word[1:], row, col - 1) or \\\n self.existRecu(deepcopy(board), word[1:], row, col + 1)","def is_word(self, word):\r\n\r\n return self.data(word) is not None","def contains(self, word: str) -> bool:\n if not isinstance(word, str):\n raise TypeError('word argument must be str')\n\n current = self._base\n for character in word + '$':\n try:\n current = current[character]\n except KeyError:\n return False\n else:\n return True","def test_contains_returns_true_for_partial_word_in_multi_word_trie(multi_trie):\n assert multi_trie.contains(\"hell\") is True","def search(self, word):\n if not word:\n return False\n if '.' not in word:\n return word in self.word_dict[len(word)]\n for v in self.word_dict[len(word)]:\n for i, ch in enumerate(word):\n if ch != v[i] and ch != '.':\n break\n else:\n return True\n return False","def __contains__(self, word):\n if word in self.vocab:\n return True\n else:\n char_ngrams = compute_ngrams(word, self.min_n, self.max_n)\n return any(ng in self.ngrams for ng in char_ngrams)","def search(self, word: str) -> bool:\n m = len(word)\n\n for dict_word in self.dict[m]:\n i = 0\n while i < m:\n if (word[i] == dict_word[i]) or (word[i] == '.'):\n i += 1\n else:\n break\n\n if i == m:\n return True\n\n return False","def basic_check(word):\n if word[-1] == \"b\" or word[-1] == \"g\":\n return False\n consonant_counter = 0\n for char in word:\n if char in VOWELS:\n consonant_counter = 0\n else:\n consonant_counter += 1\n if consonant_counter >= 3:\n return False\n return True","def search(self, word: str, current_node=None) -> bool:\n\t\tif current_node == None:\n\t\t\tcurrent_node = self.root\n\t\tfor ch in word:\n\t\t\tfound_in_child = False\n\t\t\tfor node in current_node.children:\n\t\t\t\tif node.char == ch:\n\t\t\t\t\tfound_in_child = True\n\t\t\t\t\tcurrent_node = node\n\t\t\tif found_in_child == False: # some char not found anywhere\n\t\t\t\treturn False\n\t\tif current_node.completeWord:\n\t\t\treturn True\n\t\treturn False","def word_dict_contains (self,\r\n word):\r\n\r\n\r\n\r\n if self.using_database:\r\n aprint('WORDDICT CONTAINS')\r\n\r\n value_tuple = (notebookname, word,)\r\n db_cursor.execute(\"SELECT rowid\"\r\n +\" FROM word_to_indexes\"\r\n +\" WHERE notebook=?\"\r\n +\" AND word=?;\",\r\n value_tuple)\r\n try:\r\n return db_cursor.fetchone()[0] # MIGHT BE PROBLEMATIC\r\n except:\r\n return False\r\n\r\n return str(word) in self.word_dict","def isWord(word, dictionary):\n return word in dictionary","def test_contains_returns_false_when_word_not_in_trie(empty_trie, full_trie):\n assert empty_trie.contains(\"goodbye\") is False\n assert full_trie.contains(\"goodbye\") is False","def isUnique(self, word):\n if len(word) <= 1:\n n = word\n else:\n n = word[0] + str(len(word) - 2) + word[-1] #Get the abbrviation.\n if n not in self.abbrdict or (self.abbrdict[n] == 1 and word in self.origdict): #If it is not in abbrdict or the abbrevation count is 1 and the word has appeared in dictionary, return true.\n return True\n else: #Otherwise, return false.\n return False","def search(self, word: 'str') -> 'bool':\n \n def dfs(word,dictword):\n if not word: \n if '#' in dictword:\n return True\n else:\n return False\n for k in range(len(word)):\n if word[k]!='.':\n if word[k] not in dictword:\n return False\n else:\n return dfs(word[k+1:],dictword[word[k]])\n else:\n for ss in 'qwertyuiopasdfghjklzxcvbnm':\n if ss in dictword and dfs(word[k+1:],dictword[ss]):\n return True\n return False\n return dfs(word,self.dictword)"],"string":"[\n \"def is_word(trie, string: str) -> bool:\\n return any(w == string for w in trie)\",\n \"def search(self, word):\\n curr = self.trie\\n for i, ch in enumerate(word):\\n curr = curr.get(ch, {})\\n if curr:\\n continue\\n else:\\n break\\n \\n if i==len(word)-1 and '\\\\0' in curr:\\n ret = True\\n else:\\n ret = False\\n\\n return ret\",\n \"def has_word(self, word)->bool:\\n if len(word) == 1:\\n chars = word + GNode.CHAR_EOW\\n else:\\n chars = word[0] + GNode.CHAR_REV + word[1:] + GNode.CHAR_EOW\\n cursor = self.root\\n for c in chars.lower():\\n if c not in cursor.children:\\n return False\\n else:\\n cursor = cursor.children[c]\\n return True\",\n \"def search(self, word):\\n length = len(word)\\n if length == 1:\\n for letter in string.ascii_lowercase:\\n key = \\\"{}/{}\\\".format(1, letter)\\n if key in self.origin and letter != word:\\n return True\\n return False\\n\\n key = \\\"{}/{}\\\".format(len(word), word[0])\\n ls = self.origin.get(key, [])\\n if len(ls) == 0:\\n return False\\n\\n for origin in ls:\\n if self.only_modify_one_char(word, origin):\\n return True\\n return False\",\n \"def in_trie(self, trie, word):\\n current_dict = trie\\n for letter in word:\\n if letter in current_dict:\\n current_dict = current_dict[letter]\\n else:\\n return False\\n else:\\n if '_end_' in current_dict:\\n return current_dict['_end_']\\n else:\\n return False\\n return False\",\n \"def search(self, word):\\n level = self.trie\\n for c in word:\\n if c in level:\\n level = level[c]\\n else:\\n return False\\n return self.end in level\",\n \"def search_full_word(self, word):\\n node = self.root\\n for i in range(len(word)):\\n current_letter = word[i]\\n current_index = self.to_index(current_letter)\\n if node.children[current_index] and node.is_word:\\n node = node.children[current_index]\\n else:\\n return False\\n # save last node after a search\\n self.saved_node = node\\n return True\",\n \"def search(self, word):\\n if not word:\\n return False\\n if word[0] not in self.trie:\\n return False\\n cur = self.trie[word[0]]\\n for char in word[1:]:\\n if char not in cur.nexts:\\n return False\\n cur = cur.nexts[char]\\n return (cur and cur.isTerm) == True\",\n \"def search(self, word: str) -> bool:\\n tries = [self.trie]\\n for c in word:\\n if c != '.':\\n tries = [\\n trie[c] for trie in tries if c in trie\\n ]\\n else:\\n tries = [\\n v for trie in tries for v in trie.values() if v\\n ]\\n\\n if not tries:\\n return False\\n\\n return any(None in trie for trie in tries)\",\n \"def search(self, word):\\r\\n t = self.trie\\r\\n for w in word: \\r\\n if w not in t: \\r\\n return False\\r\\n t = t[w]\\r\\n if '#' in t:\\r\\n return True\\r\\n return False\",\n \"def search(self, word: str) -> bool:\\n node = self.root\\n for char in word:\\n if char not in node:\\n return False\\n node = node[char]\\n return self.end_of_word in node\",\n \"def search(self, word: str) -> bool:\\r\\n nroot=self.root\\r\\n for j in word:\\r\\n \\r\\n # index=ord(j)-ord('a')\\r\\n if j not in nroot.children:\\r\\n return False\\r\\n nroot=nroot.children[j] \\r\\n return nroot.endofword\",\n \"def search(self, word):\\n for i in xrange(len(word)):\\n w = word[:i] + '*' + word[i+1:]\\n if w in self.dict and (len(self.dict[w]) > 1 or word[i] not in self.dict[w]): return True \\n return False\",\n \"def search(self, word: str) -> bool:\\n cur = self.root\\n for letter in word:\\n if letter not in cur:\\n return False\\n cur = cur[letter]\\n if \\\"isWord\\\" not in cur:\\n return False\\n return True\",\n \"def search(self, word: str) -> bool:\\n temp=self.root\\n \\n for char in word:\\n if(not temp.children[ord(char)-ord('a')]):\\n return False\\n temp=temp.children[ord(char)-ord('a')]\\n \\n if(temp and temp.endOfWord==True):\\n return True\\n \\n return False\",\n \"def check_present_and_add(self, word):\\n\\n current_node = self.root_node\\n is_new_word = False\\n\\n # iterate through trie adding missing notes\\n for char in word:\\n if char not in current_node:\\n is_new_word = True\\n current_node[char] = {}\\n current_node = current_node[char]\\n \\n # mark end of word so that words that are prefixes of present words are not\\n # returned - i.e. each word must have an explicit \\\"End of Word\\\" marker\\n if \\\"End of Word\\\" not in current_node:\\n is_new_word = True\\n current_node[\\\"End on Word\\\"] = {}\\n\\n return is_new_word\",\n \"def check_word(self, word):\\n\\n if not self.words:\\n return None\\n word = ''.join(word)\\n return next((True for w in self.words if w == word), False)\",\n \"def search(self, word: str) -> bool:\\n current = self.root\\n for letter in word: \\n current = current.children.get(letter)\\n if not current:\\n return False\\n return current.is_word\",\n \"def checkWord(self, word):\\n\\t\\treturn self.root.checkString(u' ' + word);\",\n \"def search(self, word: str) -> bool:\\n return self.trie.search(word + '#', self.trie.trie)\",\n \"def search(self, word):\\n node = self.root\\n for char in word:\\n if char in node.dict:\\n node = node.dict[char]\\n else:\\n return False\\n if node.end:\\n return True\\n return False\",\n \"def search(self, word: str, root: dict = None) -> bool:\\n word += '0'\\n return self._search(word, self.trie)\",\n \"def search(self, word: str) -> bool:\\n node = self.root\\n for c in word:\\n if c not in node:\\n return False\\n node = node[c]\\n return self.end in node\",\n \"def checkWord(word):\\r\\n check = word in cachedWordList\\r\\n if check:\\r\\n print(word + \\\" spelt correctly\\\")\\r\\n else:\\r\\n print(word + \\\" not found in dictionary\\\")\\r\\n return check\",\n \"def contains_word(root, input_word):\\n\\n cNode = root\\n\\n for char in list(input_word):\\n found_match = False\\n for node in cNode.nodes:\\n if node.char == char:\\n found_match = True\\n cNode = node\\n break\\n\\n if not found_match:\\n print(\\\"Exited in for loop\\\")\\n return False\\n\\n return cNode.is_word\",\n \"def search(self, word):\\n current = self.root\\n for i in word:\\n if current.hash_map.get(i) is None:\\n return False\\n current = current.hash_map.get(i)\\n if current.num != 0:\\n return True\\n return False\",\n \"def search(self, word: str) -> bool:\\r\\n node=self.root\\r\\n for c in word:\\r\\n if c not in node:\\r\\n return False\\r\\n else:\\r\\n node = node[c]\\r\\n if self.end_of_words in node:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def search(self, word: str) -> bool:\\n #start from the root\\n node = self.root\\n for char in word:\\n if char in node.child:\\n node = node.child.get(char)\\n else:\\n return False\\n return node.isWord\",\n \"def search(self, word):\\n #edge case\\n if word == \\\"\\\": \\n return True if self._dict.children[26] != None else False\\n\\n cur = self._dict\\n for c in word:\\n ind = ord(c) - 97\\n if cur.children[ind] == None:\\n return False\\n cur = cur.children[ind]\\n\\n return True if cur.isleaf == True else False\",\n \"def search(self, word):\\n current = self.root\\n for letter in word:\\n current = current.children.get(letter)\\n \\n if current is None:\\n return False\\n return current.is_word\",\n \"def search(self, word: str) -> bool:\\n node = self\\n for c in word:\\n node = node.d.get(c)\\n if not node:\\n return False\\n return node.end\",\n \"def search(self, word: str) -> bool:\\n n = self.root\\n for l in word[0:-1]:\\n cn = n.get_child_with_val(l)\\n if cn == None or cn.eow:\\n return False\\n n = cn\\n\\n last_node = n.get_eow_child_with_val(word[-1])\\n if last_node == None:\\n return False\\n return True\",\n \"def search(self, word):\\n if len(word) not in self.length_set:\\n return False\\n for i in self.mutate(word):\\n if i in self.s:\\n return True\\n return False\",\n \"def search(self, word: str) -> bool:\\n curr = self.root\\n for c in word:\\n if not c in curr.adj:\\n return False\\n curr = curr.adj[c]\\n return curr.isWord\",\n \"def search(self, word: str) -> bool:\\n node = self.root\\n for c in word:\\n if c not in node.children:\\n return False\\n node = node.children[c]\\n return True\",\n \"def search(self, word: str) -> bool:\\n def DFS(i, word, trie):\\n if i == len(word):\\n return '#' in trie\\n # c == '.'\\n # c in trie\\n c = word[i]\\n res = False\\n if c == '.':\\n for cc in trie.keys():\\n if cc != '#':\\n res = res or DFS(i + 1, word, trie[cc])\\n elif word[i] in trie:\\n res = res or DFS(i + 1, word, trie[c])\\n return res\\n\\n return DFS(0, word, self.trie)\",\n \"def search(self, word: str) -> bool:\\n node = self.root\\n for w in word:\\n node = node.children.get(w)\\n if not node:\\n return False\\n return node.end\",\n \"def search(self, word: str) -> bool:\\n curr = self.root\\n for ch in word:\\n curr = curr.children.get(ch)\\n if curr is None:\\n return False\\n return curr.is_word\",\n \"def search(self, word: str) -> bool:\\n def recur(word, trie):\\n if not word:\\n if '$' in trie:\\n return True\\n return False\\n if word[0] in trie:\\n return recur(word[1:], trie[word[0]])\\n elif word[0] == '.':\\n to_return = False\\n for char in trie.keys():\\n to_return = to_return or recur(word[1:], trie[char])\\n return to_return\\n return False\\n return recur(word, self.trie)\",\n \"def search(self, word):\\n curNode = self.root\\n for c in word:\\n if not c in curNode:\\n return False\\n curNode = curNode[c]\\n \\n # Doesn't end here\\n if not self.end in curNode:\\n return False\\n \\n return True\",\n \"def search(self, word: str) -> bool:\\n if len(word) == 0:\\n return True\\n idx = ord(word[0]) - ord('a')\\n if not self.children[idx]:\\n return False\\n if len(word) == 1:\\n return self.children[idx].tail # switch for only once\\n\\n return self.children[idx].search(word[1:])\",\n \"def search(self, word):\\n pointer = self.tries\\n for i in range(len(word)):\\n ascii = ord(word[i]) - ord('a')\\n if pointer[ascii] == None:\\n return False\\n pointer = pointer[ascii]\\n if word in pointer[26:]:\\n return True\\n else:\\n return False\",\n \"def search(self, word: str) -> bool:\\n curr_chars = self.chars\\n for c in list(word):\\n if c not in curr_chars:\\n return False\\n curr_chars = curr_chars[c]\\n return self.end_of_word in curr_chars\",\n \"def search(self, word):\\n node = self.root\\n for letter in word:\\n if letter not in node.children:\\n return False\\n node = node.children[letter]\\n return node.endOfWord\",\n \"def search(self, word: str) -> bool:\\n parent = self.root\\n for char in word:\\n if char not in parent.children:\\n return False\\n parent = parent.children[char]\\n return parent.endhere\",\n \"def search(self, word):\\n now = self.tree\\n for i in word:\\n if i in now:\\n now = now[i]\\n else:\\n return False\\n return True if 'end' in now else False\",\n \"def search(self, word: str) -> bool:\\n node = self.root\\n for char in word:\\n if char not in node:\\n return False\\n node = node[char]\\n if \\\"#\\\" not in node:\\n return False\\n return True\",\n \"def search_word(self, word):\\n current = self.root\\n for letter in word:\\n \\n current = current.get_child(letter) # node is not next letter in word\\n\\n if not current: # if node is null, return False\\n return False\\n \\n if not current.get_end():\\n return False\\n return True\",\n \"def search(self, word: str) -> bool:\\n\\n temp = self.start\\n\\n for i in range(len(word)):\\n \\n if temp.children[ord(word[i]) - ord('a')] is None:\\n return False\\n temp = temp.children[ord(word[i])-ord('a')]\\n if i+1 == len(word) and temp.end == True:\\n return True\\n\\n return False\",\n \"def search(self, word):\\n node = self.root\\n for c in word:\\n if c in node.children:\\n node = node.children[c]\\n else:\\n return False\\n return node.word_end\",\n \"def search(self, word: str) -> bool:\\n current = self.root\\n for letter in word:\\n if letter not in current.children:\\n return False\\n current = current.children[letter]\\n return current.has_end\",\n \"def search(self, word):\\n node = self.root\\n for letter in word:\\n if letter not in node.children:\\n return False\\n node = node.children[letter]\\n return node.word\",\n \"def search(self, word):\\n curr = [self.trie]\\n\\n for c in word:\\n next_curr = []\\n if c != '.':\\n for n in curr:\\n if c in n.children:\\n next_curr.append(n.children[c])\\n else:\\n for n in curr:\\n next_curr.extend(n.children.values())\\n curr = next_curr\\n if not curr:\\n return False\\n\\n return any([n.is_term for n in curr])\",\n \"def search(self, word: str) -> bool:\\n currnode=self.root\\n\\n for ch in word:\\n node=currnode.children.get(ch)\\n if node is None:\\n return False\\n\\n return currNode.isWordEnd\",\n \"def check_word(words, word):\\r\\n if word in words:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def has_word(self, word):\\n return word in self.word_set\",\n \"def search(self, word):\\n if len(word) == 0:\\n return False\\n todo = [self]\\n for idx, letter in enumerate(word):\\n if len(todo) == 0:\\n break\\n new_todo = []\\n if letter == '.':\\n for node in todo:\\n new_todo += list(node.kids.values())\\n else:\\n for node in todo:\\n if letter in node.kids:\\n new_todo.append(node.kids[letter])\\n if idx == len(word) - 1 and node.kids[letter].isWord:\\n return True\\n todo = new_todo\\n if len(todo) > 0 and word[-1] == '.':\\n for ele in todo:\\n if ele.isWord:\\n return True\\n\\n return False\",\n \"def search(self, word):\\n node = self.search_prefix(word)\\n return node is not None and '#' in node and node['#'] == 1\",\n \"def search(self, word):\\n currNode = self.root\\n\\n for c in word:\\n if c not in currNode.children:\\n return False\\n currNode = currNode.children[c]\\n return currNode.isEnd\",\n \"def search(self, word: str) -> bool:\\n node = self.head\\n for c in word:\\n if c not in node.next:\\n return False\\n node = node.next[c]\\n return node.valid\",\n \"def search(self, word):\\n lenw = len(word)\\n if lenw not in self.bag: return False\\n return any([self.equal_to(word, item) for item in self.bag[lenw]])\",\n \"def search(self, word) -> bool:\\n return self.match(self.root, 0, word)\",\n \"def search(self, word: str):\\n node = self.root\\n for letter in word:\\n if letter in node.child:\\n node = node.child[letter]\\n else:\\n return False\\n return node.is_leaf\",\n \"def check_match(self, word_found,word): \\r\\n self.count = 0\\r\\n for char in self.word_found:\\r\\n if char != self.word[self.count]:\\r\\n return False\\r\\n self.count +=1\\r\\n #print(self.count)\\r\\n \\r\\n return True\",\n \"def search(self, word: str) -> bool:\\n node = self._traverse(word)\\n return node.word if node else False\",\n \"def search(self, word: 'str') -> 'bool':\\n p = self.root\\n for ch in word:\\n if ch in p:\\n p = p[ch]\\n else:\\n return False\\n\\n if '#' in p:\\n return True\\n else:\\n return False\",\n \"def check_word(self, word):\\n first_letter, rest = word[0], word[1:]\\n\\n for possible_start in self._find_letter(first_letter):\\n if self._check_word(possible_start, rest):\\n return True\\n\\n return False\",\n \"def search(self, word):\\n def r_search(word,i,d):\\n if len(word) <= i:\\n return True\\n \\n if d == 0:\\n return False\\n \\n return (word[i] in d) and r_search(word,i+1,d[word[i]])\\n \\n tri = self.root.d\\n if len(word) == 0: \\n return True\\n \\n if len(tri) == 0:\\n return False\\n \\n return r_search(word + '$',0,tri)\",\n \"def check_word(word):\\r\\n if word in word_master:\\r\\n valid = True\\r\\n else:\\r\\n valid = False\\r\\n return valid\",\n \"def word_check(word):\\n word1 = word[1:]\\n if word1 not in word_dict: return False\\n if not homophones (word, word1): return False\\n \\n \\n word2 = word[0] + word[2:]\\n if word2 not in word_dict: return False\\n if not homophones(word, word2): return False\\n\\n return True\",\n \"def search(self, word: str) -> bool:\\n node = self.find(word)\\n return node and node.is_word\",\n \"def search(self, word: str) -> bool:\\n return self.search_recursive(self.root, word, 0)\",\n \"def search(self, word: str) -> bool:\\n tmp = self.root\\n for i in range(len(word)): \\n if word[i] == \\\".\\\":\\n valid = False\\n for nxt in tmp.seq.keys():\\n valid = valid or self.search(word[:i] + nxt + word[i+1:])\\n \\n if valid:\\n return True\\n return False\\n \\n if word[i] not in tmp.seq:\\n return False \\n tmp = tmp.seq[word[i]]\\n \\n return tmp.value == word\",\n \"def search(self, word):\\n node = self.root\\n for i in word:\\n if i not in node.children:\\n return False\\n node = node.children[i]\\n return node.word\",\n \"def search(self, word):\\n length = len(word)\\n if length not in self.dic:\\n return False\\n else:\\n candidateList = self.dic[length]\\n for candidate in candidateList:\\n for i in xrange(length):\\n if candidate[i] != word[i]:\\n if candidate[i+1:] == word[i+1:]:\\n return True\\n else:\\n break\\n return False\",\n \"def chars_match (found, word):\\n index = 0\\n for i in found:\\n if (i != word[index]):\\n return False\\n index += 1\\n return True\",\n \"def check_word(self, word):\\n word = word.lower().strip()\\n return not word or word in self.dictionary\",\n \"def valid_word(self, word):\\n\\n word = ''.join(word)\\n return next((w for w in self.words if w == word), None)\",\n \"def contains(self, word: Iterable[Terminal]) -> bool:\\n return self._get_final_state(word) is not None\",\n \"def test_contains_returns_false_when_word_mismatches(full_trie):\\n assert full_trie.contains(\\\"hello\\\") is False\",\n \"def search(self, word):\\n for wc in self.get_wildcards(word):\\n # Don't forget word not in self.all_words\\n if wc in self.wc_dict and (self.wc_dict[wc] > 1 or word not in self.all_words) :\\n return True\\n return False\",\n \"def test_contains_returns_true_when_word_in_trie(full_trie):\\n assert full_trie.contains(\\\"hey\\\") is True\",\n \"def search(self, word):\\n end_node = self.__find_node(word)\\n if end_node and end_node.is_word:\\n return True\\n return False\",\n \"def check(self,word):\\n if self.pre:\\n def sub_word(chars):\\n if re.match('^'+chars+'.*',word):\\n return word[len(chars):]\\n else:\\n return None\\n else:\\n def sub_word(chars):\\n if re.match('^.*'+chars+'$',word):\\n return word[:-len(chars)]\\n else:\\n return None\\n\\n if word == '':\\n return self\\n for chars in self.branches.keys():\\n res = sub_word(chars)\\n if res:\\n return self.branches[chars].check(res)\\n elif res == '':\\n return self.branches[chars]\\n return None\",\n \"def search(self, word):\\n for candidate in self.candidates(word):\\n if self.neighbors[candidate] > 1:\\n return True\\n elif self.neighbors[candidate] == 1 and word not in self.word_set:\\n return True\\n return False\",\n \"def trifeca(word):\\n if not word:\\n return False\\n\\n for i in range(len(word)-1):\\n if word[i]==word[i+1]:\\n if len(word[i:])>=6:\\n if word[i+2:i+6:2]==word[i+3:i+7:2]:\\n return True \\n return False\",\n \"def existRecu(self, board, word, row, col) -> bool:\\n if len(word) == 0:\\n return True\\n elif row < 0 or row == len(board): # Edge breaking\\n return False\\n elif col < 0 or col == len(board[0]): # Edge breaking\\n return False\\n elif board[row][col] is None:\\n return False\\n elif board[row][col] != word[0]: # miss-matching\\n return False\\n else:\\n board[row][col] = None\\n return self.existRecu(deepcopy(board), word[1:], row - 1, col) or \\\\\\n self.existRecu(deepcopy(board), word[1:], row + 1, col) or \\\\\\n self.existRecu(deepcopy(board), word[1:], row, col - 1) or \\\\\\n self.existRecu(deepcopy(board), word[1:], row, col + 1)\",\n \"def is_word(self, word):\\r\\n\\r\\n return self.data(word) is not None\",\n \"def contains(self, word: str) -> bool:\\n if not isinstance(word, str):\\n raise TypeError('word argument must be str')\\n\\n current = self._base\\n for character in word + '$':\\n try:\\n current = current[character]\\n except KeyError:\\n return False\\n else:\\n return True\",\n \"def test_contains_returns_true_for_partial_word_in_multi_word_trie(multi_trie):\\n assert multi_trie.contains(\\\"hell\\\") is True\",\n \"def search(self, word):\\n if not word:\\n return False\\n if '.' not in word:\\n return word in self.word_dict[len(word)]\\n for v in self.word_dict[len(word)]:\\n for i, ch in enumerate(word):\\n if ch != v[i] and ch != '.':\\n break\\n else:\\n return True\\n return False\",\n \"def __contains__(self, word):\\n if word in self.vocab:\\n return True\\n else:\\n char_ngrams = compute_ngrams(word, self.min_n, self.max_n)\\n return any(ng in self.ngrams for ng in char_ngrams)\",\n \"def search(self, word: str) -> bool:\\n m = len(word)\\n\\n for dict_word in self.dict[m]:\\n i = 0\\n while i < m:\\n if (word[i] == dict_word[i]) or (word[i] == '.'):\\n i += 1\\n else:\\n break\\n\\n if i == m:\\n return True\\n\\n return False\",\n \"def basic_check(word):\\n if word[-1] == \\\"b\\\" or word[-1] == \\\"g\\\":\\n return False\\n consonant_counter = 0\\n for char in word:\\n if char in VOWELS:\\n consonant_counter = 0\\n else:\\n consonant_counter += 1\\n if consonant_counter >= 3:\\n return False\\n return True\",\n \"def search(self, word: str, current_node=None) -> bool:\\n\\t\\tif current_node == None:\\n\\t\\t\\tcurrent_node = self.root\\n\\t\\tfor ch in word:\\n\\t\\t\\tfound_in_child = False\\n\\t\\t\\tfor node in current_node.children:\\n\\t\\t\\t\\tif node.char == ch:\\n\\t\\t\\t\\t\\tfound_in_child = True\\n\\t\\t\\t\\t\\tcurrent_node = node\\n\\t\\t\\tif found_in_child == False: # some char not found anywhere\\n\\t\\t\\t\\treturn False\\n\\t\\tif current_node.completeWord:\\n\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def word_dict_contains (self,\\r\\n word):\\r\\n\\r\\n\\r\\n\\r\\n if self.using_database:\\r\\n aprint('WORDDICT CONTAINS')\\r\\n\\r\\n value_tuple = (notebookname, word,)\\r\\n db_cursor.execute(\\\"SELECT rowid\\\"\\r\\n +\\\" FROM word_to_indexes\\\"\\r\\n +\\\" WHERE notebook=?\\\"\\r\\n +\\\" AND word=?;\\\",\\r\\n value_tuple)\\r\\n try:\\r\\n return db_cursor.fetchone()[0] # MIGHT BE PROBLEMATIC\\r\\n except:\\r\\n return False\\r\\n\\r\\n return str(word) in self.word_dict\",\n \"def isWord(word, dictionary):\\n return word in dictionary\",\n \"def test_contains_returns_false_when_word_not_in_trie(empty_trie, full_trie):\\n assert empty_trie.contains(\\\"goodbye\\\") is False\\n assert full_trie.contains(\\\"goodbye\\\") is False\",\n \"def isUnique(self, word):\\n if len(word) <= 1:\\n n = word\\n else:\\n n = word[0] + str(len(word) - 2) + word[-1] #Get the abbrviation.\\n if n not in self.abbrdict or (self.abbrdict[n] == 1 and word in self.origdict): #If it is not in abbrdict or the abbrevation count is 1 and the word has appeared in dictionary, return true.\\n return True\\n else: #Otherwise, return false.\\n return False\",\n \"def search(self, word: 'str') -> 'bool':\\n \\n def dfs(word,dictword):\\n if not word: \\n if '#' in dictword:\\n return True\\n else:\\n return False\\n for k in range(len(word)):\\n if word[k]!='.':\\n if word[k] not in dictword:\\n return False\\n else:\\n return dfs(word[k+1:],dictword[word[k]])\\n else:\\n for ss in 'qwertyuiopasdfghjklzxcvbnm':\\n if ss in dictword and dfs(word[k+1:],dictword[ss]):\\n return True\\n return False\\n return dfs(word,self.dictword)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7898829","0.77123356","0.76817137","0.7651471","0.74973875","0.7494274","0.7490946","0.7471417","0.7440383","0.7440078","0.74153924","0.74125475","0.73968333","0.7382937","0.73649126","0.7333139","0.73310703","0.7293905","0.729297","0.72762936","0.7275739","0.7211364","0.72047067","0.72003835","0.7198947","0.7198598","0.71788365","0.71755683","0.7160483","0.7130068","0.7127907","0.7124436","0.71228695","0.70993555","0.709855","0.7091737","0.7072758","0.7069442","0.70634663","0.7062562","0.7016676","0.7000654","0.6995837","0.6994039","0.6986388","0.6974976","0.6960983","0.6959844","0.6952699","0.6942338","0.69327486","0.6931396","0.693002","0.69217825","0.68994135","0.6897771","0.688772","0.6882916","0.68795663","0.6873254","0.6862361","0.68558645","0.6835378","0.6818395","0.68171716","0.6799035","0.6796226","0.6790387","0.67855227","0.6781026","0.67724997","0.6772053","0.67699677","0.67619","0.6748994","0.6747389","0.6742173","0.6734318","0.67328864","0.6721488","0.66796464","0.6677644","0.6670951","0.6667653","0.66529036","0.6651965","0.6614682","0.66124547","0.6597147","0.6595557","0.65923715","0.65825653","0.6559314","0.65043974","0.65025234","0.6498732","0.64883184","0.6487576","0.64751035","0.6463183"],"string":"[\n \"0.7898829\",\n \"0.77123356\",\n \"0.76817137\",\n \"0.7651471\",\n \"0.74973875\",\n \"0.7494274\",\n \"0.7490946\",\n \"0.7471417\",\n \"0.7440383\",\n \"0.7440078\",\n \"0.74153924\",\n \"0.74125475\",\n \"0.73968333\",\n \"0.7382937\",\n \"0.73649126\",\n \"0.7333139\",\n \"0.73310703\",\n \"0.7293905\",\n \"0.729297\",\n \"0.72762936\",\n \"0.7275739\",\n \"0.7211364\",\n \"0.72047067\",\n \"0.72003835\",\n \"0.7198947\",\n \"0.7198598\",\n \"0.71788365\",\n \"0.71755683\",\n \"0.7160483\",\n \"0.7130068\",\n \"0.7127907\",\n \"0.7124436\",\n \"0.71228695\",\n \"0.70993555\",\n \"0.709855\",\n \"0.7091737\",\n \"0.7072758\",\n \"0.7069442\",\n \"0.70634663\",\n \"0.7062562\",\n \"0.7016676\",\n \"0.7000654\",\n \"0.6995837\",\n \"0.6994039\",\n \"0.6986388\",\n \"0.6974976\",\n \"0.6960983\",\n \"0.6959844\",\n \"0.6952699\",\n \"0.6942338\",\n \"0.69327486\",\n \"0.6931396\",\n \"0.693002\",\n \"0.69217825\",\n \"0.68994135\",\n \"0.6897771\",\n \"0.688772\",\n \"0.6882916\",\n \"0.68795663\",\n \"0.6873254\",\n \"0.6862361\",\n \"0.68558645\",\n \"0.6835378\",\n \"0.6818395\",\n \"0.68171716\",\n \"0.6799035\",\n \"0.6796226\",\n \"0.6790387\",\n \"0.67855227\",\n \"0.6781026\",\n \"0.67724997\",\n \"0.6772053\",\n \"0.67699677\",\n \"0.67619\",\n \"0.6748994\",\n \"0.6747389\",\n \"0.6742173\",\n \"0.6734318\",\n \"0.67328864\",\n \"0.6721488\",\n \"0.66796464\",\n \"0.6677644\",\n \"0.6670951\",\n \"0.6667653\",\n \"0.66529036\",\n \"0.6651965\",\n \"0.6614682\",\n \"0.66124547\",\n \"0.6597147\",\n \"0.6595557\",\n \"0.65923715\",\n \"0.65825653\",\n \"0.6559314\",\n \"0.65043974\",\n \"0.65025234\",\n \"0.6498732\",\n \"0.64883184\",\n \"0.6487576\",\n \"0.64751035\",\n \"0.6463183\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.664082"},"document_rank":{"kind":"string","value":"86"}}},{"rowIdx":4490,"cells":{"query":{"kind":"string","value":"Load twine from a .json filename, filelike or a json string and validates twine contents."},"document":{"kind":"string","value":"def _load_twine(self, source=None):\n if source is None:\n # If loading an unspecified twine, return an empty one rather than raising error (like in _load_data())\n raw_twine = {}\n logger.warning(\"No twine source specified. Loading empty twine.\")\n else:\n raw_twine = self._load_json(\"twine\", source, allowed_kinds=(\"file-like\", \"filename\", \"string\", \"object\"))\n\n self._validate_against_schema(\"twine\", raw_twine)\n self._validate_twine_version(twine_file_twined_version=raw_twine.get(\"twined_version\", None))\n return raw_twine"},"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 load_tweets(filename):\n\n try:\n with open(filename, 'r') as f:\n data = json.loads(f.read())\n except:\n print('ERROR in load_tweets.')\n\n return data","def test_loader_loads_from_file():\n base_json = 'tests/test_json.json'\n json_test = {\"foo\": \"bar\"}\n assert whenzat.loader(base_json) == json_test","def loadFromFile(self, filename):\n with open(filename, 'r') as file:\n raw_data = file.read()\n # data = json.loads(raw_data, encoding='utf-8') # python 3.9 suppression de encoding\n try:\n data = json.loads(raw_data)\n self.deserialize(data)\n self.has_been_modified = False\n except json.JSONDecodeError:\n raise InvalidFile(f'{os.path.basename(filename)} is not a valid JSON file')\n except Exception as e:\n dumpException(e)","def load(filename):\n\n try:\n with open(filename) as data:\n return json.load(data)\n except:\n return None","def load_json_fixture(filename: str) -> Any:\n return json.loads(load_fixture(f\"jellyfin/{filename}\"))","def sniff( self, filename ):\r\n try:\r\n json.load( open(filename) )\r\n return True\r\n except Exception:\r\n return False","def load_json(path, name):\n if 'txt' not in name:\n name += '.json'\n with open(os.path.join(path, name), 'r') as json_file:\n return json.load(json_file)","def test_loads_a_non_object_json_file(self):\n from test.resources import simple_json\n self.assertEqual(simple_json._data, 'test')","def load_tweets(file):\n with open(file) as f:\n data = json.load(f)\n return data","def test_load_json_str():\n\n file_name = 'test_fooof_all'\n\n data = load_json(file_name, TEST_DATA_PATH)\n\n assert data","def test_loader_loads_from_str():\n base_json = '{\"foo\": \"bar\"}'\n json_test = {\"foo\": \"bar\"}\n assert whenzat.loader(base_json, from_file=False) == json_test","def test_verifies_token_file_contains_json(self):\n\n with open(self.sample_token_file, 'w',\n encoding=\"utf8\", errors=\"surrogateescape\") as stf_h:\n stf_h.write(\"Bad JSON\")\n\n with self.assertRaises(json.decoder.JSONDecodeError):\n badgr = BadgrLite(token_filename=self.sample_token_file)\n badgr.load_token()","def json_loader(filename):\n\n with open(filename, \"r\", encoding=\"UTF-8\") as source:\n data = json.load(source, object_hook=object_decode)\n return data","def load_from_json_file(filename):\n if type(filename) is not str:\n return\n\n with open(filename, mode=\"r\") as file:\n return json.loads(file.read())","def load_json(filepath: str):\n with open(filepath, \"r\", encoding=\"utf8\") as f:\n return json.loads(f.read())","def from_file(filename):\n # in order to complete this lab we are going to use the python lib json in which we have the function json.loads\n # which will automatically load a json from a string\n f = open(filename, 'r')\n string = f.read()\n return json.loads(string)","def load_json_data(filepath):\n with open(filepath,'r') as f:\n return json.load(f)","def read(self,filename):\n with open(str(filename),\"r\") as f:\n data = f.read()\n #check if the loaded file is json\n try:\n datajson = json.loads(data)\n except Exception as e:\n if mer == True:\n merrors.error('could not load '+str(filename)+', add a basic entry to the config like {\"name\":\"Example\"}. Python error: '+str(e))\n quit()\n else:\n print(\"could not load \"+str(filename)+\". Python error: \"+str(e))\n quit()\n self.datajson = datajson\n self.filename = filename\n f.close()","def load_json(filepath: str):\n with open(filepath, encoding=\"utf-8\") as f:\n return json.load(f)","def load_from_json_file(filename):\n with open(filename, encoding=\"utf-8\") as round:\n return json.load(round)","def load_life(name):\n\tif not '.json' in name:\n\t\tname += '.json'\n\t\n\twith open(os.path.join(LIFE_DIR, name), 'r') as e:\n\t\treturn json.loads(''.join(e.readlines()))","def load(self):\n with io.open(self.filename, encoding='utf-8') as f:\n self.load_from_dict(json.loads(f.read()))","def __load_json(self, path):\n try:\n with Path(path).open('r') as f:\n return json.load(f)\n except ValueError as ve:\n six.raise_from(ValueError(\"error while loading the fixture %s\" % path), ve)","def load(self):\n filename = self._filename\n if not os.path.exists(filename):\n self.service.log.store('Cannot load %s, does not exist' % filename)\n return False\n \n # Read from file\n self.service.log.store('Loading %s' % filename)\n f = open(filename, 'r')\n raw = f.read()\n f.close()\n \n self.from_json(raw)\n return True","def load_tweets(fname):\n tweets = []\n for line in open(fname):\n tweets.append(json.loads(line))\n return tweets","def _loadf(fname):\n with open(fname, encoding=\"ISO-8859-1\") as f:\n return json.load(f)","def load_from_file(self, filepath, validate=True, results=None):\n with open(filepath) as fd:\n try:\n data = json.load(fd)\n except ValueError as ex:\n ex = JSONEncodingError(ex)\n if not results:\n raise ex\n results.add(filepath, ex)\n return results\n\n return self.load(data, validate=validate, results=results, id=filepath)","def test_load_unsupported_type(self):\n expected = {\n \"name\": \"Kevin\",\n \"age\": 21,\n \"pet\": {\n \"name\": \"Trippy Jack\",\n \"age\": 20762,\n \"__type__\": \"hyperdimensional.hamster\"\n }\n }\n with open('tests/unsupported_type.json', 'r') as json_file:\n self.assertEqual(expected, morejson.load(json_file))","def loadJSON(jsonData):\n\n if hasattr(jsonData, 'read'):\n loadedjson = json.load(jsonData)\n elif isinstance(jsonData, str):\n if os.path.exists(jsonData):\n with open(jsonData) as jsonFile:\n loadedjson = json.load(jsonFile)\n else:\n try:\n loadedjson = json.loads(jsonData)\n except JSONDecodeError as e:\n raise ValueError(f\" {str(e)}: Got {jsonData}, either bad format of file does not exist\")\n\n elif isinstance(jsonData, dict):\n loadedjson = jsonData\n else:\n err = f\"workflow type: {type(jsonData)} is unknonw. Must be str, file-like or dict. \"\n raise ValueError(err)\n\n\n return loadedjson","def read_object_from_file(file_name):\n if os.path.exists(file_name) is False:\n print (\"Error read path: [%s]\" % file_name)\n return None\n with open(file_name, 'r') as f:\n try:\n obj = json.load(f)\n except Exception:\n print (\"Error json: [%s]\" % f.read()[0:10])\n return None\n return obj","def test_load_an_object_json_file(self):\n from test.resources import object_json\n self.assertEqual(object_json._data, {'answer': 42})\n self.assertEqual(len(object_json), 1)\n self.assertEqual(object_json['answer'], 42)","def load_from_json_file(filename):\n with open(filename, 'r') as f:\n obj = json.loads(f.read())\n return obj","def from_JSON(cls, filename):\n with open(os.path.expanduser(filename), encoding='utf-8') as f:\n return json.load(f, object_hook=class_hook)","def process_jsonld_file(fname):\n with open(fname, 'r', encoding='utf-8') as fh:\n json_dict = json.load(fh)\n return process_jsonld(json_dict)","def test_load_an_object_json_file(self):\n from test.resources import malaga\n self.assertEqual(len(malaga.data), 5018112)\n self.assertEqual(malaga.Model, 'iPhone 4')","def _localloadjson(path: str) -> JSONType:\n with open(path, encoding=\"utf-8\") as fh:\n return json.load(fh)","def load_from_json_file(filename):\n with open(filename, \"r\") as my_file:\n return json.loads(my_file.read())","def loadJson (self, path):\n\n # get all lines in json, concatenate then into a big string then parse it\n with open(path, \"r\") as file_content:\n all_lines = file_content.readlines()\n all_content_str = \"\".join(all_lines)\n json_dict = json.loads(all_content_str)\n self.tile_reprs = list(json_dict['tiles']['structural-tiles'].keys())\n\n # remove this empty char\n self.tile_reprs.remove(\"-\")","def _load(self):\n if self.file_path.exists():\n with open(self.file_path) as fid:\n self.data = json.load(fid)","def test_valid_json():\n invalid_json = False\n for filename in os.listdir(\"../networking\"):\n if filename.endswith(\".cfn.json\"):\n print(\"Validating json file: %s\" % filename)\n with open(f\"../networking/{filename}\", encoding=\"utf-8\") as f:\n try:\n json.load(f)\n print(\"SUCCESS: Valid json.\")\n except ValueError as e:\n print(\"ERROR: Invalid json: %s\" % e)\n invalid_json = True\n\n assert not invalid_json","def load_rentals_file(filename):\n logging.debug('Loading rental file %s', filename)\n try:\n with open(filename) as file:\n try:\n data = json.load(file)\n except ValueError:\n logging.error('File %s cannot be read as JSON', filename)\n exit(0)\n except IOError:\n logging.error('File %s cannot be read (does not exist?)', filename)\n exit(0)\n logging.debug('Successfully loaded rental file %s', filename)\n return data","def load():\n try:\n with open('learn.json', 'r') as file:\n return json.load(file)\n except IOError:\n return []","def load_from_json_file(filename):\n with open(filename, mode=\"r\", encoding=\"utf-8\") as a_file:\n return json.loads(a_file.read())","def json_load(file_path):\n\n with open(file_path) as f:\n return json_loads(f.read())","def loadJSONFile(filename):\n\twith open(filename, 'r') as f:\n\t\treturn json.loads(f.read())","def load(filename):\n if str(filename).endswith('.yml') or str(filename).endswith('.yaml'):\n return load_yaml(filename)\n elif str(filename).endswith('.json'):\n return load_json(filename)","def load_hyp(filepath):\n with open(filepath, 'r') as f:\n return json.load(f)","def load_json(file_name):\n return json.load(open(file_name))","def load_from_json(self, json_fp: str):\n # TODO:\n pass","def load(self):\n data = None\n try:\n with open(self.__filepath, 'r') as file:\n text = file.read()\n data = jsonpickle.decode(text)\n except FileNotFoundError:\n data = None\n except IOError as e:\n print(e)\n return data","def from_file(cls, file_name):\n\n with open(file_name, 'r') as fi:\n the_dict = json.load(fi)\n return cls.from_dict(the_dict)","def load_from_json_file(filename):\n with open(filename, 'r', encoding='utf8') as f:\n return json.load(f)","def load(self, s):\n self._filename = s\n # self._isLoaded = True\n with open(s, 'r') as f:\n self._dict = json.load(f)","def load(file, **kwargs):\n extension = os.path.splitext(file)\n if extension not in {'.json', '.axjson'}:\n raise RuntimeError('Given extension ({}) not supported'.format(extension))\n with open(file) as f:\n data = json.load(f)\n if extension == '.json':\n return data\n else:\n json_str = json.dumps(data)\n return loads(json_str, **kwargs)","def load_json_document(f):\n return json.load(f)","def test_validate_file_extension_json(self):\n data_locations = open(self.test_dir + 'mannheim_short.json',\n encoding='utf-8')\n data_locations_false = open(self.test_dir + 'contacts.csv',\n encoding='utf-8')\n a = validate_file_extension_json(data_locations)\n self.assertEqual(a, None)\n with self.assertRaises(ValidationError) as context:\n validate_file_extension_json(data_locations_false)\n data_locations.close()\n data_locations_false.close()\n self.assertTrue(\"Kein gültiges JSON-File\" or \"No valid JSON file\" in\n str(context.exception))","def test_load_json_fobj():\n\n file_name = 'test_fooof_all'\n\n with open(os.path.join(TEST_DATA_PATH, file_name + '.json'), 'r') as f_obj:\n data = load_json(f_obj, '')\n\n assert data","def _load(self, json_str, filepath):\n # pylint: disable=protected-access\n return self.json_o._load(json_str, filepath)","def load_from_json_file(filename):\n with open(filename) as f:\n return json.load(f)","def load(self):\n if not self.exist:\n self.create()\n\n with open(self.file_path, encoding=Config.ENCODING) as file:\n self.data = json.load(file)","def loadTweets(filename):\n tweets = open(filename, 'r').read().splitlines()\n print \"Loading %d tweets from %s ...\" % (len(tweets), filename)\n tweetObjects = []\n for tweet in tweets:\n try:\n js = json.loads(tweet)\n if (not ('place' in js)) or js['place'] == None:\n continue\n elif (not ('full_name' in js['place'])):\n continue\n elif (not ('geo' in js)) or js['geo'] == None:\n continue\n elif (not ('coordinates' in js['geo'])):\n continue\n coords = js['geo']['coordinates']\n place = js['place']\n tweetObject = Tweet(js['text'], place['full_name'], coords[0], coords[1], place['country'], js['created_at'])\n tweetObjects.append(tweetObject)\n except ValueError:\n pass\n print \"Loaded %d tweets\" % len(tweetObjects)\n return tweetObjects","def load_from_json_file(filename):\n with open(filename, \"r\", encoding=\"utf-8\") as f:\n return(json.loads(f.read()))","def load(filename):\n if filename.endswith('.yml') or filename.endswith('.yaml'):\n return load_yml(filename)\n elif filename.endswith('.json'):\n return load_json(filename)","def read_json_breakdown(cls, fname):\n if not os.path.exists(fname):\n raise RuntimeError\n\n with open(fname, 'r') as data_file:\n return cls.fixup_from_json(data_file.read())","def readf(self, fileName):\n\t\tif os.path.exists(fileName):\n\t\t\tf = open(fileName)\n\t\t\ttry:\n\t\t\t\td = json.load(f)\n\t\t\texcept Exception as e:\n\t\t\t\tlog.error(e)\n\t\t\t\tf.close()\n\t\t\t\treturn None\n\t\t\telse:\n\t\t\t\treturn self.readd(d)\n\t\t\t\tf.close()","def load_stat(input):\n with open(input['json'], 'r', encoding=input['encoding']) as f:\n return json.load(f)","def load_text(txt_path):\n with open(txt_path, 'r') as json_file:\n data = json_file.read()\n content = json.loads(data)\n \n return content","def load_from_json_file(filename):\n import json\n with open(filename, 'r') as s:\n return json.load(s)","def load_from_utterance_file(filename, utterance_start_index, utterance_end_index):\n with open(filename, \"r\") as f:\n try:\n ext = filename.split(\".\")[-1]\n if ext == \"json\":\n utterances = json.load(f)\n elif ext == \"jsonl\":\n utterances = []\n if utterance_start_index is None: utterance_start_index = 0\n if utterance_end_index is None: utterance_end_index = float('inf')\n idx = 0\n for line in f:\n if utterance_start_index <= idx <= utterance_end_index:\n utterances.append(json.loads(line))\n idx += 1\n except Exception as e:\n raise Exception(\"Could not load corpus. Expected json file, encountered error: \\n\" + str(e))\n return utterances","def from_json_file(filename, check_format=True):\n filename = os.path.abspath(filename)\n directory = os.path.dirname(filename)\n with open(filename, \"r\") as infile:\n return ExperimentListFactory.from_json(\n infile.read(), check_format=check_format, directory=directory\n )","def load_json(filename):\n with open(filename) as file:\n obj = json.load(file)\n return obj","def load_json(filepath: str):\n if not filepath:\n return None\n\n abs_path = _resolve_relative_path(filepath)\n with open(abs_path) as f:\n raw_json = f.read()\n\n return json.loads(raw_json)","def file_jsoncheck(filename):\n with open(filename, 'r') as jsontable:\n try:\n json_object = json.load(jsontable)\n except ValueError, e:\n return False\n\n # DQLL.json number of lines should be 35\n # Will change with table version\n nlines = 35\n \n with open(filename, 'r') as f:\n l = [x for x in f.readlines()]\n # Default number of lines should be 35\n if len(l) != nlines:\n print \"Number of lines in DQLL.json is not default {} but {}\".format(nlines, len(l))\n return False\n\n return True","def load_data_file(path):\n with open(path, encoding='utf-8') as f:\n return json.load(f)","def from_file(cls, file_name: str):\n\n with open(file_name, 'r') as fi:\n input_dict = json.load(fi)\n return cls.from_dict(input_dict)","def load_from_json(file):\n with open(file, 'r') as f:\n return json.load(f)","def validate_input(update_file):\n try:\n json.load(open(update_file))\n print \"\\nValid JSON\"\n return True\n except ValueError:\n print \"\\nInvalid JSON\"\n exit(-1)\n return False","def __init__(self, filename):\n #Opening the file and storing its contents in a list\n with open(filename) as fp:\n self.data = json.load(fp)","def test_load_file_contents():\n\n file_name = 'test_fooof_all'\n loaded_data = load_json(file_name, TEST_DATA_PATH)\n\n # Check settings\n for setting in OBJ_DESC['settings']:\n assert setting in loaded_data.keys()\n\n # Check results\n for result in OBJ_DESC['results']:\n assert result in loaded_data.keys()\n\n # Check results\n for datum in OBJ_DESC['data']:\n assert datum in loaded_data.keys()","def load_json(fpath):\n with open(fpath, \"r\") as f:\n return json.load(f)","def import_sample(infile):\n deserialized = None\n with open(infile, 'r') as file_handle:\n deserialized = json.load(file_handle, object_hook=decode_sample)\n return deserialized","def loadJsonFromFile(filename):\n with open(filename) as f:\n return json.loads(f.read())","def load_from_json(filename):\n\n with open(filename, 'r') as file:\n return json.load(file)","def test_load_json_file_not_found_error() -> None:\n fname = \"invalid_file.json\"\n\n assert load_json(fname) == {}\n assert load_json(fname, default=\"\") == \"\"\n assert load_json_object(fname) == {}\n assert load_json_object(fname, default={\"Hi\": \"Peter\"}) == {\"Hi\": \"Peter\"}\n assert load_json_array(fname) == []\n assert load_json_array(fname, default=[\"Hi\"]) == [\"Hi\"]","def load_data(filename):\n # Load JSON lines\n with open(filename, encoding='utf-8') as f:\n examples = [json.loads(line) for line in f]\n\n return examples","def from_json(path: str):\n with open(path) as f:\n return json.load(f)","def load_json_obj(path: str) -> RAW_CFG:\n with fsspec.open(path) as json_file:\n return json.load(json_file)","def load(self, filepath):\n yaml_load = lambda fp: yaml.load(fp, Loader=yaml.SafeLoader)\n reader = json.load if Config.isjson(filepath) else yaml_load\n with open(filepath, 'r') as f:\n self.__init__(reader(f))\n return self","def load_json(filename_or_dict):\n\tif isinstance(filename_or_dict, str):\n\t\tinput_file = open(filename_or_dict, encoding='utf-8')\n\t\tjson_dict = json.loads(input_file.read())\n\t\tinput_file.close()\n\t\treturn json_dict\n\treturn filename_or_dict","def validate_input(update_file):\n try:\n json.load(open(update_file))\n #print \"Valid JSON\"\n return True\n except ValueError:\n print \"Invalid JSON. Exiting.\"\n exit(-1)\n return False","def load_from_json(self, file_name: str) -> bool:\n try:\n with open(file_name, 'r') as f:\n data = json.loads(f.read())\n self.__g = DiGraph.from_dict(data)\n return True\n except:\n traceback.print_exc()\n return False","def load_json(filename):\n\n with open(filename, encoding=constants.load_encoding) as file:\n return loads(file.read())","def util_load_json(path):\n with io.open(path, mode=\"r\", encoding=\"utf-8\") as f:\n return json.loads(f.read())","def load(config_file: typing.TextIO) -> \"TrainingConfig\":\n return TrainingConfig.from_json(config_file.read())","def read_twitter_json(f):\n tweets = list()\n with open(f) as json_file:\n for line in json_file:\n tweets.append(json.loads(line))\n return tweets","def load_json_file(i):\n\n import json\n\n fn = i['json_file']\n\n try:\n if sys.version_info[0] > 2:\n f = open(fn, 'r', encoding='utf8')\n else:\n f = open(fn, 'r')\n except Exception as e:\n return {'return': 16, 'error': 'problem opening json file='+fn+' ('+format(e)+')'}\n\n try:\n s = f.read()\n except Exception as e:\n f.close()\n return {'return': 1, 'error': 'problem reading json file='+fn+' ('+format(e)+')'}\n\n f.close()\n\n try:\n if sys.version_info[0] > 2:\n d = json.loads(s)\n else:\n d = json.loads(s, encoding='utf8')\n except Exception as e:\n return {'return': 1, 'error': 'problem parsing json from file='+fn+' ('+format(e)+')'}\n\n return {'return': 0, 'dict': d}","def from_json_file(cls, json_file:str):\n with open(json_file) as file:\n data = json.load(file)\n validate(data, schema)\n instance = cls.from_dict(data)\n return instance","def ler_json() -> dict:\n\n try:\n data = None\n with open('/home/kurt/GitHub/geobit_test/data.json') as json_file: \n data = json.load(json_file)\n \n return data\n \n except:\n return print(\n \"There was a problem executing the'ler_son' function from the leitura file\")","def load(self, file=\"setup\", path=\"settings\"):\n\n # check if filename already contains file extension, if not, add it\n if file[-5:] != '.json':\n file += '.json'\n # load mappings from file\n with open(os.path.join(path, file), 'r') as file:\n self.data = json.load(file)","def load():\n\n #: the file passed by the user in the post request\n file = request.files[\"file\"]\n\n # ensure that file exists\n if file == None:\n return BadRequest(\"No file given\")\n\n # ensure that file is readable\n try:\n file = json.loads(file.read())\n except UnicodeDecodeError:\n return BadRequest(\"Invalid file\")\n \n # ensure that the file can be indexed\n try:\n points = file[\"points\"]\n reg_json = file[\"reg\"]\n except TypeError:\n return BadRequest(\"Invalid file\")\n\n global no_dimensions\n #: number of dimensions\n no_dimensions = file[\"no_dimensions\"]\n\n\n # give each point an annotation weight if it does not already have one\n for i in range(0, len(points)):\n if points[i].get(\"annot_weight\") == None:\n points[i][\"annot_weight\"] = random.uniform(0, 1)\n\n global reg \n # regression model loaded from file\n if not reg_json:\n reg = jsonpickle.loads(reg_json)\n\n global tsne \n tsne = points\n \n return {\"points\": points, \"reg\": reg != None, \"no_dimensions\": no_dimensions}"],"string":"[\n \"def load_tweets(filename):\\n\\n try:\\n with open(filename, 'r') as f:\\n data = json.loads(f.read())\\n except:\\n print('ERROR in load_tweets.')\\n\\n return data\",\n \"def test_loader_loads_from_file():\\n base_json = 'tests/test_json.json'\\n json_test = {\\\"foo\\\": \\\"bar\\\"}\\n assert whenzat.loader(base_json) == json_test\",\n \"def loadFromFile(self, filename):\\n with open(filename, 'r') as file:\\n raw_data = file.read()\\n # data = json.loads(raw_data, encoding='utf-8') # python 3.9 suppression de encoding\\n try:\\n data = json.loads(raw_data)\\n self.deserialize(data)\\n self.has_been_modified = False\\n except json.JSONDecodeError:\\n raise InvalidFile(f'{os.path.basename(filename)} is not a valid JSON file')\\n except Exception as e:\\n dumpException(e)\",\n \"def load(filename):\\n\\n try:\\n with open(filename) as data:\\n return json.load(data)\\n except:\\n return None\",\n \"def load_json_fixture(filename: str) -> Any:\\n return json.loads(load_fixture(f\\\"jellyfin/{filename}\\\"))\",\n \"def sniff( self, filename ):\\r\\n try:\\r\\n json.load( open(filename) )\\r\\n return True\\r\\n except Exception:\\r\\n return False\",\n \"def load_json(path, name):\\n if 'txt' not in name:\\n name += '.json'\\n with open(os.path.join(path, name), 'r') as json_file:\\n return json.load(json_file)\",\n \"def test_loads_a_non_object_json_file(self):\\n from test.resources import simple_json\\n self.assertEqual(simple_json._data, 'test')\",\n \"def load_tweets(file):\\n with open(file) as f:\\n data = json.load(f)\\n return data\",\n \"def test_load_json_str():\\n\\n file_name = 'test_fooof_all'\\n\\n data = load_json(file_name, TEST_DATA_PATH)\\n\\n assert data\",\n \"def test_loader_loads_from_str():\\n base_json = '{\\\"foo\\\": \\\"bar\\\"}'\\n json_test = {\\\"foo\\\": \\\"bar\\\"}\\n assert whenzat.loader(base_json, from_file=False) == json_test\",\n \"def test_verifies_token_file_contains_json(self):\\n\\n with open(self.sample_token_file, 'w',\\n encoding=\\\"utf8\\\", errors=\\\"surrogateescape\\\") as stf_h:\\n stf_h.write(\\\"Bad JSON\\\")\\n\\n with self.assertRaises(json.decoder.JSONDecodeError):\\n badgr = BadgrLite(token_filename=self.sample_token_file)\\n badgr.load_token()\",\n \"def json_loader(filename):\\n\\n with open(filename, \\\"r\\\", encoding=\\\"UTF-8\\\") as source:\\n data = json.load(source, object_hook=object_decode)\\n return data\",\n \"def load_from_json_file(filename):\\n if type(filename) is not str:\\n return\\n\\n with open(filename, mode=\\\"r\\\") as file:\\n return json.loads(file.read())\",\n \"def load_json(filepath: str):\\n with open(filepath, \\\"r\\\", encoding=\\\"utf8\\\") as f:\\n return json.loads(f.read())\",\n \"def from_file(filename):\\n # in order to complete this lab we are going to use the python lib json in which we have the function json.loads\\n # which will automatically load a json from a string\\n f = open(filename, 'r')\\n string = f.read()\\n return json.loads(string)\",\n \"def load_json_data(filepath):\\n with open(filepath,'r') as f:\\n return json.load(f)\",\n \"def read(self,filename):\\n with open(str(filename),\\\"r\\\") as f:\\n data = f.read()\\n #check if the loaded file is json\\n try:\\n datajson = json.loads(data)\\n except Exception as e:\\n if mer == True:\\n merrors.error('could not load '+str(filename)+', add a basic entry to the config like {\\\"name\\\":\\\"Example\\\"}. Python error: '+str(e))\\n quit()\\n else:\\n print(\\\"could not load \\\"+str(filename)+\\\". Python error: \\\"+str(e))\\n quit()\\n self.datajson = datajson\\n self.filename = filename\\n f.close()\",\n \"def load_json(filepath: str):\\n with open(filepath, encoding=\\\"utf-8\\\") as f:\\n return json.load(f)\",\n \"def load_from_json_file(filename):\\n with open(filename, encoding=\\\"utf-8\\\") as round:\\n return json.load(round)\",\n \"def load_life(name):\\n\\tif not '.json' in name:\\n\\t\\tname += '.json'\\n\\t\\n\\twith open(os.path.join(LIFE_DIR, name), 'r') as e:\\n\\t\\treturn json.loads(''.join(e.readlines()))\",\n \"def load(self):\\n with io.open(self.filename, encoding='utf-8') as f:\\n self.load_from_dict(json.loads(f.read()))\",\n \"def __load_json(self, path):\\n try:\\n with Path(path).open('r') as f:\\n return json.load(f)\\n except ValueError as ve:\\n six.raise_from(ValueError(\\\"error while loading the fixture %s\\\" % path), ve)\",\n \"def load(self):\\n filename = self._filename\\n if not os.path.exists(filename):\\n self.service.log.store('Cannot load %s, does not exist' % filename)\\n return False\\n \\n # Read from file\\n self.service.log.store('Loading %s' % filename)\\n f = open(filename, 'r')\\n raw = f.read()\\n f.close()\\n \\n self.from_json(raw)\\n return True\",\n \"def load_tweets(fname):\\n tweets = []\\n for line in open(fname):\\n tweets.append(json.loads(line))\\n return tweets\",\n \"def _loadf(fname):\\n with open(fname, encoding=\\\"ISO-8859-1\\\") as f:\\n return json.load(f)\",\n \"def load_from_file(self, filepath, validate=True, results=None):\\n with open(filepath) as fd:\\n try:\\n data = json.load(fd)\\n except ValueError as ex:\\n ex = JSONEncodingError(ex)\\n if not results:\\n raise ex\\n results.add(filepath, ex)\\n return results\\n\\n return self.load(data, validate=validate, results=results, id=filepath)\",\n \"def test_load_unsupported_type(self):\\n expected = {\\n \\\"name\\\": \\\"Kevin\\\",\\n \\\"age\\\": 21,\\n \\\"pet\\\": {\\n \\\"name\\\": \\\"Trippy Jack\\\",\\n \\\"age\\\": 20762,\\n \\\"__type__\\\": \\\"hyperdimensional.hamster\\\"\\n }\\n }\\n with open('tests/unsupported_type.json', 'r') as json_file:\\n self.assertEqual(expected, morejson.load(json_file))\",\n \"def loadJSON(jsonData):\\n\\n if hasattr(jsonData, 'read'):\\n loadedjson = json.load(jsonData)\\n elif isinstance(jsonData, str):\\n if os.path.exists(jsonData):\\n with open(jsonData) as jsonFile:\\n loadedjson = json.load(jsonFile)\\n else:\\n try:\\n loadedjson = json.loads(jsonData)\\n except JSONDecodeError as e:\\n raise ValueError(f\\\" {str(e)}: Got {jsonData}, either bad format of file does not exist\\\")\\n\\n elif isinstance(jsonData, dict):\\n loadedjson = jsonData\\n else:\\n err = f\\\"workflow type: {type(jsonData)} is unknonw. Must be str, file-like or dict. \\\"\\n raise ValueError(err)\\n\\n\\n return loadedjson\",\n \"def read_object_from_file(file_name):\\n if os.path.exists(file_name) is False:\\n print (\\\"Error read path: [%s]\\\" % file_name)\\n return None\\n with open(file_name, 'r') as f:\\n try:\\n obj = json.load(f)\\n except Exception:\\n print (\\\"Error json: [%s]\\\" % f.read()[0:10])\\n return None\\n return obj\",\n \"def test_load_an_object_json_file(self):\\n from test.resources import object_json\\n self.assertEqual(object_json._data, {'answer': 42})\\n self.assertEqual(len(object_json), 1)\\n self.assertEqual(object_json['answer'], 42)\",\n \"def load_from_json_file(filename):\\n with open(filename, 'r') as f:\\n obj = json.loads(f.read())\\n return obj\",\n \"def from_JSON(cls, filename):\\n with open(os.path.expanduser(filename), encoding='utf-8') as f:\\n return json.load(f, object_hook=class_hook)\",\n \"def process_jsonld_file(fname):\\n with open(fname, 'r', encoding='utf-8') as fh:\\n json_dict = json.load(fh)\\n return process_jsonld(json_dict)\",\n \"def test_load_an_object_json_file(self):\\n from test.resources import malaga\\n self.assertEqual(len(malaga.data), 5018112)\\n self.assertEqual(malaga.Model, 'iPhone 4')\",\n \"def _localloadjson(path: str) -> JSONType:\\n with open(path, encoding=\\\"utf-8\\\") as fh:\\n return json.load(fh)\",\n \"def load_from_json_file(filename):\\n with open(filename, \\\"r\\\") as my_file:\\n return json.loads(my_file.read())\",\n \"def loadJson (self, path):\\n\\n # get all lines in json, concatenate then into a big string then parse it\\n with open(path, \\\"r\\\") as file_content:\\n all_lines = file_content.readlines()\\n all_content_str = \\\"\\\".join(all_lines)\\n json_dict = json.loads(all_content_str)\\n self.tile_reprs = list(json_dict['tiles']['structural-tiles'].keys())\\n\\n # remove this empty char\\n self.tile_reprs.remove(\\\"-\\\")\",\n \"def _load(self):\\n if self.file_path.exists():\\n with open(self.file_path) as fid:\\n self.data = json.load(fid)\",\n \"def test_valid_json():\\n invalid_json = False\\n for filename in os.listdir(\\\"../networking\\\"):\\n if filename.endswith(\\\".cfn.json\\\"):\\n print(\\\"Validating json file: %s\\\" % filename)\\n with open(f\\\"../networking/{filename}\\\", encoding=\\\"utf-8\\\") as f:\\n try:\\n json.load(f)\\n print(\\\"SUCCESS: Valid json.\\\")\\n except ValueError as e:\\n print(\\\"ERROR: Invalid json: %s\\\" % e)\\n invalid_json = True\\n\\n assert not invalid_json\",\n \"def load_rentals_file(filename):\\n logging.debug('Loading rental file %s', filename)\\n try:\\n with open(filename) as file:\\n try:\\n data = json.load(file)\\n except ValueError:\\n logging.error('File %s cannot be read as JSON', filename)\\n exit(0)\\n except IOError:\\n logging.error('File %s cannot be read (does not exist?)', filename)\\n exit(0)\\n logging.debug('Successfully loaded rental file %s', filename)\\n return data\",\n \"def load():\\n try:\\n with open('learn.json', 'r') as file:\\n return json.load(file)\\n except IOError:\\n return []\",\n \"def load_from_json_file(filename):\\n with open(filename, mode=\\\"r\\\", encoding=\\\"utf-8\\\") as a_file:\\n return json.loads(a_file.read())\",\n \"def json_load(file_path):\\n\\n with open(file_path) as f:\\n return json_loads(f.read())\",\n \"def loadJSONFile(filename):\\n\\twith open(filename, 'r') as f:\\n\\t\\treturn json.loads(f.read())\",\n \"def load(filename):\\n if str(filename).endswith('.yml') or str(filename).endswith('.yaml'):\\n return load_yaml(filename)\\n elif str(filename).endswith('.json'):\\n return load_json(filename)\",\n \"def load_hyp(filepath):\\n with open(filepath, 'r') as f:\\n return json.load(f)\",\n \"def load_json(file_name):\\n return json.load(open(file_name))\",\n \"def load_from_json(self, json_fp: str):\\n # TODO:\\n pass\",\n \"def load(self):\\n data = None\\n try:\\n with open(self.__filepath, 'r') as file:\\n text = file.read()\\n data = jsonpickle.decode(text)\\n except FileNotFoundError:\\n data = None\\n except IOError as e:\\n print(e)\\n return data\",\n \"def from_file(cls, file_name):\\n\\n with open(file_name, 'r') as fi:\\n the_dict = json.load(fi)\\n return cls.from_dict(the_dict)\",\n \"def load_from_json_file(filename):\\n with open(filename, 'r', encoding='utf8') as f:\\n return json.load(f)\",\n \"def load(self, s):\\n self._filename = s\\n # self._isLoaded = True\\n with open(s, 'r') as f:\\n self._dict = json.load(f)\",\n \"def load(file, **kwargs):\\n extension = os.path.splitext(file)\\n if extension not in {'.json', '.axjson'}:\\n raise RuntimeError('Given extension ({}) not supported'.format(extension))\\n with open(file) as f:\\n data = json.load(f)\\n if extension == '.json':\\n return data\\n else:\\n json_str = json.dumps(data)\\n return loads(json_str, **kwargs)\",\n \"def load_json_document(f):\\n return json.load(f)\",\n \"def test_validate_file_extension_json(self):\\n data_locations = open(self.test_dir + 'mannheim_short.json',\\n encoding='utf-8')\\n data_locations_false = open(self.test_dir + 'contacts.csv',\\n encoding='utf-8')\\n a = validate_file_extension_json(data_locations)\\n self.assertEqual(a, None)\\n with self.assertRaises(ValidationError) as context:\\n validate_file_extension_json(data_locations_false)\\n data_locations.close()\\n data_locations_false.close()\\n self.assertTrue(\\\"Kein gültiges JSON-File\\\" or \\\"No valid JSON file\\\" in\\n str(context.exception))\",\n \"def test_load_json_fobj():\\n\\n file_name = 'test_fooof_all'\\n\\n with open(os.path.join(TEST_DATA_PATH, file_name + '.json'), 'r') as f_obj:\\n data = load_json(f_obj, '')\\n\\n assert data\",\n \"def _load(self, json_str, filepath):\\n # pylint: disable=protected-access\\n return self.json_o._load(json_str, filepath)\",\n \"def load_from_json_file(filename):\\n with open(filename) as f:\\n return json.load(f)\",\n \"def load(self):\\n if not self.exist:\\n self.create()\\n\\n with open(self.file_path, encoding=Config.ENCODING) as file:\\n self.data = json.load(file)\",\n \"def loadTweets(filename):\\n tweets = open(filename, 'r').read().splitlines()\\n print \\\"Loading %d tweets from %s ...\\\" % (len(tweets), filename)\\n tweetObjects = []\\n for tweet in tweets:\\n try:\\n js = json.loads(tweet)\\n if (not ('place' in js)) or js['place'] == None:\\n continue\\n elif (not ('full_name' in js['place'])):\\n continue\\n elif (not ('geo' in js)) or js['geo'] == None:\\n continue\\n elif (not ('coordinates' in js['geo'])):\\n continue\\n coords = js['geo']['coordinates']\\n place = js['place']\\n tweetObject = Tweet(js['text'], place['full_name'], coords[0], coords[1], place['country'], js['created_at'])\\n tweetObjects.append(tweetObject)\\n except ValueError:\\n pass\\n print \\\"Loaded %d tweets\\\" % len(tweetObjects)\\n return tweetObjects\",\n \"def load_from_json_file(filename):\\n with open(filename, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n return(json.loads(f.read()))\",\n \"def load(filename):\\n if filename.endswith('.yml') or filename.endswith('.yaml'):\\n return load_yml(filename)\\n elif filename.endswith('.json'):\\n return load_json(filename)\",\n \"def read_json_breakdown(cls, fname):\\n if not os.path.exists(fname):\\n raise RuntimeError\\n\\n with open(fname, 'r') as data_file:\\n return cls.fixup_from_json(data_file.read())\",\n \"def readf(self, fileName):\\n\\t\\tif os.path.exists(fileName):\\n\\t\\t\\tf = open(fileName)\\n\\t\\t\\ttry:\\n\\t\\t\\t\\td = json.load(f)\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tlog.error(e)\\n\\t\\t\\t\\tf.close()\\n\\t\\t\\t\\treturn None\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn self.readd(d)\\n\\t\\t\\t\\tf.close()\",\n \"def load_stat(input):\\n with open(input['json'], 'r', encoding=input['encoding']) as f:\\n return json.load(f)\",\n \"def load_text(txt_path):\\n with open(txt_path, 'r') as json_file:\\n data = json_file.read()\\n content = json.loads(data)\\n \\n return content\",\n \"def load_from_json_file(filename):\\n import json\\n with open(filename, 'r') as s:\\n return json.load(s)\",\n \"def load_from_utterance_file(filename, utterance_start_index, utterance_end_index):\\n with open(filename, \\\"r\\\") as f:\\n try:\\n ext = filename.split(\\\".\\\")[-1]\\n if ext == \\\"json\\\":\\n utterances = json.load(f)\\n elif ext == \\\"jsonl\\\":\\n utterances = []\\n if utterance_start_index is None: utterance_start_index = 0\\n if utterance_end_index is None: utterance_end_index = float('inf')\\n idx = 0\\n for line in f:\\n if utterance_start_index <= idx <= utterance_end_index:\\n utterances.append(json.loads(line))\\n idx += 1\\n except Exception as e:\\n raise Exception(\\\"Could not load corpus. Expected json file, encountered error: \\\\n\\\" + str(e))\\n return utterances\",\n \"def from_json_file(filename, check_format=True):\\n filename = os.path.abspath(filename)\\n directory = os.path.dirname(filename)\\n with open(filename, \\\"r\\\") as infile:\\n return ExperimentListFactory.from_json(\\n infile.read(), check_format=check_format, directory=directory\\n )\",\n \"def load_json(filename):\\n with open(filename) as file:\\n obj = json.load(file)\\n return obj\",\n \"def load_json(filepath: str):\\n if not filepath:\\n return None\\n\\n abs_path = _resolve_relative_path(filepath)\\n with open(abs_path) as f:\\n raw_json = f.read()\\n\\n return json.loads(raw_json)\",\n \"def file_jsoncheck(filename):\\n with open(filename, 'r') as jsontable:\\n try:\\n json_object = json.load(jsontable)\\n except ValueError, e:\\n return False\\n\\n # DQLL.json number of lines should be 35\\n # Will change with table version\\n nlines = 35\\n \\n with open(filename, 'r') as f:\\n l = [x for x in f.readlines()]\\n # Default number of lines should be 35\\n if len(l) != nlines:\\n print \\\"Number of lines in DQLL.json is not default {} but {}\\\".format(nlines, len(l))\\n return False\\n\\n return True\",\n \"def load_data_file(path):\\n with open(path, encoding='utf-8') as f:\\n return json.load(f)\",\n \"def from_file(cls, file_name: str):\\n\\n with open(file_name, 'r') as fi:\\n input_dict = json.load(fi)\\n return cls.from_dict(input_dict)\",\n \"def load_from_json(file):\\n with open(file, 'r') as f:\\n return json.load(f)\",\n \"def validate_input(update_file):\\n try:\\n json.load(open(update_file))\\n print \\\"\\\\nValid JSON\\\"\\n return True\\n except ValueError:\\n print \\\"\\\\nInvalid JSON\\\"\\n exit(-1)\\n return False\",\n \"def __init__(self, filename):\\n #Opening the file and storing its contents in a list\\n with open(filename) as fp:\\n self.data = json.load(fp)\",\n \"def test_load_file_contents():\\n\\n file_name = 'test_fooof_all'\\n loaded_data = load_json(file_name, TEST_DATA_PATH)\\n\\n # Check settings\\n for setting in OBJ_DESC['settings']:\\n assert setting in loaded_data.keys()\\n\\n # Check results\\n for result in OBJ_DESC['results']:\\n assert result in loaded_data.keys()\\n\\n # Check results\\n for datum in OBJ_DESC['data']:\\n assert datum in loaded_data.keys()\",\n \"def load_json(fpath):\\n with open(fpath, \\\"r\\\") as f:\\n return json.load(f)\",\n \"def import_sample(infile):\\n deserialized = None\\n with open(infile, 'r') as file_handle:\\n deserialized = json.load(file_handle, object_hook=decode_sample)\\n return deserialized\",\n \"def loadJsonFromFile(filename):\\n with open(filename) as f:\\n return json.loads(f.read())\",\n \"def load_from_json(filename):\\n\\n with open(filename, 'r') as file:\\n return json.load(file)\",\n \"def test_load_json_file_not_found_error() -> None:\\n fname = \\\"invalid_file.json\\\"\\n\\n assert load_json(fname) == {}\\n assert load_json(fname, default=\\\"\\\") == \\\"\\\"\\n assert load_json_object(fname) == {}\\n assert load_json_object(fname, default={\\\"Hi\\\": \\\"Peter\\\"}) == {\\\"Hi\\\": \\\"Peter\\\"}\\n assert load_json_array(fname) == []\\n assert load_json_array(fname, default=[\\\"Hi\\\"]) == [\\\"Hi\\\"]\",\n \"def load_data(filename):\\n # Load JSON lines\\n with open(filename, encoding='utf-8') as f:\\n examples = [json.loads(line) for line in f]\\n\\n return examples\",\n \"def from_json(path: str):\\n with open(path) as f:\\n return json.load(f)\",\n \"def load_json_obj(path: str) -> RAW_CFG:\\n with fsspec.open(path) as json_file:\\n return json.load(json_file)\",\n \"def load(self, filepath):\\n yaml_load = lambda fp: yaml.load(fp, Loader=yaml.SafeLoader)\\n reader = json.load if Config.isjson(filepath) else yaml_load\\n with open(filepath, 'r') as f:\\n self.__init__(reader(f))\\n return self\",\n \"def load_json(filename_or_dict):\\n\\tif isinstance(filename_or_dict, str):\\n\\t\\tinput_file = open(filename_or_dict, encoding='utf-8')\\n\\t\\tjson_dict = json.loads(input_file.read())\\n\\t\\tinput_file.close()\\n\\t\\treturn json_dict\\n\\treturn filename_or_dict\",\n \"def validate_input(update_file):\\n try:\\n json.load(open(update_file))\\n #print \\\"Valid JSON\\\"\\n return True\\n except ValueError:\\n print \\\"Invalid JSON. Exiting.\\\"\\n exit(-1)\\n return False\",\n \"def load_from_json(self, file_name: str) -> bool:\\n try:\\n with open(file_name, 'r') as f:\\n data = json.loads(f.read())\\n self.__g = DiGraph.from_dict(data)\\n return True\\n except:\\n traceback.print_exc()\\n return False\",\n \"def load_json(filename):\\n\\n with open(filename, encoding=constants.load_encoding) as file:\\n return loads(file.read())\",\n \"def util_load_json(path):\\n with io.open(path, mode=\\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n return json.loads(f.read())\",\n \"def load(config_file: typing.TextIO) -> \\\"TrainingConfig\\\":\\n return TrainingConfig.from_json(config_file.read())\",\n \"def read_twitter_json(f):\\n tweets = list()\\n with open(f) as json_file:\\n for line in json_file:\\n tweets.append(json.loads(line))\\n return tweets\",\n \"def load_json_file(i):\\n\\n import json\\n\\n fn = i['json_file']\\n\\n try:\\n if sys.version_info[0] > 2:\\n f = open(fn, 'r', encoding='utf8')\\n else:\\n f = open(fn, 'r')\\n except Exception as e:\\n return {'return': 16, 'error': 'problem opening json file='+fn+' ('+format(e)+')'}\\n\\n try:\\n s = f.read()\\n except Exception as e:\\n f.close()\\n return {'return': 1, 'error': 'problem reading json file='+fn+' ('+format(e)+')'}\\n\\n f.close()\\n\\n try:\\n if sys.version_info[0] > 2:\\n d = json.loads(s)\\n else:\\n d = json.loads(s, encoding='utf8')\\n except Exception as e:\\n return {'return': 1, 'error': 'problem parsing json from file='+fn+' ('+format(e)+')'}\\n\\n return {'return': 0, 'dict': d}\",\n \"def from_json_file(cls, json_file:str):\\n with open(json_file) as file:\\n data = json.load(file)\\n validate(data, schema)\\n instance = cls.from_dict(data)\\n return instance\",\n \"def ler_json() -> dict:\\n\\n try:\\n data = None\\n with open('/home/kurt/GitHub/geobit_test/data.json') as json_file: \\n data = json.load(json_file)\\n \\n return data\\n \\n except:\\n return print(\\n \\\"There was a problem executing the'ler_son' function from the leitura file\\\")\",\n \"def load(self, file=\\\"setup\\\", path=\\\"settings\\\"):\\n\\n # check if filename already contains file extension, if not, add it\\n if file[-5:] != '.json':\\n file += '.json'\\n # load mappings from file\\n with open(os.path.join(path, file), 'r') as file:\\n self.data = json.load(file)\",\n \"def load():\\n\\n #: the file passed by the user in the post request\\n file = request.files[\\\"file\\\"]\\n\\n # ensure that file exists\\n if file == None:\\n return BadRequest(\\\"No file given\\\")\\n\\n # ensure that file is readable\\n try:\\n file = json.loads(file.read())\\n except UnicodeDecodeError:\\n return BadRequest(\\\"Invalid file\\\")\\n \\n # ensure that the file can be indexed\\n try:\\n points = file[\\\"points\\\"]\\n reg_json = file[\\\"reg\\\"]\\n except TypeError:\\n return BadRequest(\\\"Invalid file\\\")\\n\\n global no_dimensions\\n #: number of dimensions\\n no_dimensions = file[\\\"no_dimensions\\\"]\\n\\n\\n # give each point an annotation weight if it does not already have one\\n for i in range(0, len(points)):\\n if points[i].get(\\\"annot_weight\\\") == None:\\n points[i][\\\"annot_weight\\\"] = random.uniform(0, 1)\\n\\n global reg \\n # regression model loaded from file\\n if not reg_json:\\n reg = jsonpickle.loads(reg_json)\\n\\n global tsne \\n tsne = points\\n \\n return {\\\"points\\\": points, \\\"reg\\\": reg != None, \\\"no_dimensions\\\": no_dimensions}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64222986","0.61474323","0.6144654","0.61129427","0.6093864","0.6074711","0.6030403","0.59984696","0.59946185","0.59418505","0.59320986","0.58631575","0.5842694","0.5824927","0.57905143","0.5786703","0.5777964","0.57755256","0.5758631","0.57461494","0.57401806","0.57319224","0.5727668","0.57230777","0.5722163","0.5718931","0.5711493","0.5708973","0.5705908","0.56931615","0.56890583","0.5677451","0.56762826","0.5675732","0.56750745","0.56600446","0.5654667","0.56540126","0.5641753","0.56302345","0.5608574","0.5607227","0.5591759","0.5584992","0.5580432","0.5579113","0.5574573","0.5572174","0.5566599","0.5565561","0.5559077","0.55588394","0.5553719","0.55506176","0.55473906","0.5544015","0.5540335","0.5531413","0.55294496","0.55255836","0.55255365","0.5513949","0.5513776","0.55044395","0.5503186","0.5495519","0.5487166","0.54840565","0.5483339","0.54705507","0.5470207","0.5470051","0.5468411","0.54663163","0.54633933","0.5459222","0.54573476","0.5456068","0.5455679","0.54555684","0.54538906","0.5453326","0.54516625","0.5441221","0.5440878","0.54227215","0.54217064","0.54147315","0.54137725","0.5408543","0.5402521","0.53991574","0.53806037","0.5372282","0.5371886","0.5367621","0.5364385","0.536119","0.53594613","0.53572905"],"string":"[\n \"0.64222986\",\n \"0.61474323\",\n \"0.6144654\",\n \"0.61129427\",\n \"0.6093864\",\n \"0.6074711\",\n \"0.6030403\",\n \"0.59984696\",\n \"0.59946185\",\n \"0.59418505\",\n \"0.59320986\",\n \"0.58631575\",\n \"0.5842694\",\n \"0.5824927\",\n \"0.57905143\",\n \"0.5786703\",\n \"0.5777964\",\n \"0.57755256\",\n \"0.5758631\",\n \"0.57461494\",\n \"0.57401806\",\n \"0.57319224\",\n \"0.5727668\",\n \"0.57230777\",\n \"0.5722163\",\n \"0.5718931\",\n \"0.5711493\",\n \"0.5708973\",\n \"0.5705908\",\n \"0.56931615\",\n \"0.56890583\",\n \"0.5677451\",\n \"0.56762826\",\n \"0.5675732\",\n \"0.56750745\",\n \"0.56600446\",\n \"0.5654667\",\n \"0.56540126\",\n \"0.5641753\",\n \"0.56302345\",\n \"0.5608574\",\n \"0.5607227\",\n \"0.5591759\",\n \"0.5584992\",\n \"0.5580432\",\n \"0.5579113\",\n \"0.5574573\",\n \"0.5572174\",\n \"0.5566599\",\n \"0.5565561\",\n \"0.5559077\",\n \"0.55588394\",\n \"0.5553719\",\n \"0.55506176\",\n \"0.55473906\",\n \"0.5544015\",\n \"0.5540335\",\n \"0.5531413\",\n \"0.55294496\",\n \"0.55255836\",\n \"0.55255365\",\n \"0.5513949\",\n \"0.5513776\",\n \"0.55044395\",\n \"0.5503186\",\n \"0.5495519\",\n \"0.5487166\",\n \"0.54840565\",\n \"0.5483339\",\n \"0.54705507\",\n \"0.5470207\",\n \"0.5470051\",\n \"0.5468411\",\n \"0.54663163\",\n \"0.54633933\",\n \"0.5459222\",\n \"0.54573476\",\n \"0.5456068\",\n \"0.5455679\",\n \"0.54555684\",\n \"0.54538906\",\n \"0.5453326\",\n \"0.54516625\",\n \"0.5441221\",\n \"0.5440878\",\n \"0.54227215\",\n \"0.54217064\",\n \"0.54147315\",\n \"0.54137725\",\n \"0.5408543\",\n \"0.5402521\",\n \"0.53991574\",\n \"0.53806037\",\n \"0.5372282\",\n \"0.5371886\",\n \"0.5367621\",\n \"0.5364385\",\n \"0.536119\",\n \"0.53594613\",\n \"0.53572905\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7133785"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4491,"cells":{"query":{"kind":"string","value":"Load data from either a .json file, an open file pointer or a json string. Directly returns any other data."},"document":{"kind":"string","value":"def _load_json(self, kind, source, **kwargs):\n if source is None:\n raise exceptions.invalid_json_map[kind](f\"Cannot load {kind} - no data source specified.\")\n\n # Decode the json string and deserialize to objects.\n try:\n data = load_json(source, **kwargs)\n except FileNotFoundError as e:\n raise exceptions.file_not_found_map[kind](e)\n\n except jsonlib.decoder.JSONDecodeError as e:\n raise exceptions.invalid_json_map[kind](e)\n\n return data"},"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 _load_data_from_file(self, input_file_path):\n with FileOrBufferHandler(input_file_path, 'r', \n encoding=self.file_encoding) as input_file:\n try:\n data = json.load(input_file)\n except (json.JSONDecodeError, UnicodeDecodeError):\n input_file.seek(0)\n data = data_utils.read_json(\n data_generator=input_file,\n selected_columns=self.selected_keys,\n read_in_string=False\n )\n return data","def load(filename):\n\n try:\n with open(filename) as data:\n return json.load(data)\n except:\n return None","def _load_json_data(filename):\n\n relative_path = join(\"data\", filename)\n absolute_path = join(dirname(__file__), relative_path)\n\n with open(absolute_path) as data_file:\n return json.loads(data_file.read())","def load_json_data(filepath):\n with open(filepath,'r') as f:\n return json.load(f)","def __load_data(data_loc):\n if not data_loc.endswith('.json'):\n raise ValueError('data_loc must be a json file location.')\n with open(data_loc, 'rb') as f:\n return json.load(f)","def load(file, **kwargs):\n extension = os.path.splitext(file)\n if extension not in {'.json', '.axjson'}:\n raise RuntimeError('Given extension ({}) not supported'.format(extension))\n with open(file) as f:\n data = json.load(f)\n if extension == '.json':\n return data\n else:\n json_str = json.dumps(data)\n return loads(json_str, **kwargs)","def load_json(filename_or_dict):\n\tif isinstance(filename_or_dict, str):\n\t\tinput_file = open(filename_or_dict, encoding='utf-8')\n\t\tjson_dict = json.loads(input_file.read())\n\t\tinput_file.close()\n\t\treturn json_dict\n\treturn filename_or_dict","def read_json(file_or_path):\n try:\n with (open(file_or_path, 'r') if isinstance(file_or_path, (str, bytes)) else file_or_path) as f:\n obj = json.load(f)\n except IOError:\n obj = json.loads(file_or_path)\n return obj","def json_loader(filename):\n\n with open(filename, \"r\", encoding=\"UTF-8\") as source:\n data = json.load(source, object_hook=object_decode)\n return data","def _localloadjson(path: str) -> JSONType:\n with open(path, encoding=\"utf-8\") as fh:\n return json.load(fh)","def json_load(file_path):\n\n with open(file_path) as f:\n return json_loads(f.read())","def open_json(path):\n with open(path, \"r\") as json_data_file:\n data = json.load(json_data_file)\n return data","def load_json(file_name):\n return json.load(open(file_name))","def load_data(filename):\n with open(filename) as json_file:\n data = json.load(json_file)\n return data","def load_json(path):\n import json\n\n def _load_json(*args, **kwargs):\n with open(path) as data_file:\n return json.load(data_file)\n\n return _load_json()","def load(self):\n data = None\n try:\n with open(self.__filepath, 'r') as file:\n text = file.read()\n data = jsonpickle.decode(text)\n except FileNotFoundError:\n data = None\n except IOError as e:\n print(e)\n return data","def _load(self):\n if self.file_path.exists():\n with open(self.file_path) as fid:\n self.data = json.load(fid)","def loadJSON(jsonData):\n\n if hasattr(jsonData, 'read'):\n loadedjson = json.load(jsonData)\n elif isinstance(jsonData, str):\n if os.path.exists(jsonData):\n with open(jsonData) as jsonFile:\n loadedjson = json.load(jsonFile)\n else:\n try:\n loadedjson = json.loads(jsonData)\n except JSONDecodeError as e:\n raise ValueError(f\" {str(e)}: Got {jsonData}, either bad format of file does not exist\")\n\n elif isinstance(jsonData, dict):\n loadedjson = jsonData\n else:\n err = f\"workflow type: {type(jsonData)} is unknonw. Must be str, file-like or dict. \"\n raise ValueError(err)\n\n\n return loadedjson","def load_json(file_path):\n try:\n with open(file_path, \"r\", encoding=\"utf-8\") as f:\n data = json.load(f)\n except json.JSONDecodeError as e:\n raise ValueError(f\"Invalid JSON format in file {file_path}\") from e\n except FileNotFoundError as e:\n raise ValueError(f\"File not found: {file_path}\") from e\n return data","def read_json(self, *args, **kwargs):\n with self.open('rb') as f:\n return json.load(f, *args, **kwargs)","def json_load(fp):\n with _iotools.open_file(fp, \"r\") as f:\n return json.load(f, cls=DataDecoder)","def load_json_or_yaml(file_path):\n # handle json doc\n if isinstance(file_path, dict):\n return file_path\n # handle url\n elif file_path.startswith(\"http\"):\n with requests.get(file_path) as url:\n # check if http requests returns a success status code\n if url.status_code != 200:\n raise ValueError(f\"Invalid URL [{url.status_code}]: {file_path} !\")\n else:\n _data = url.content\n # handle file path\n else:\n try:\n with open(file_path) as f:\n _data = f.read()\n except FileNotFoundError:\n raise ValueError(\"Invalid File Path!\")\n try:\n if isinstance(_data, bytes):\n _data = _data.decode(\"utf-8\")\n data = json.loads(_data)\n # except ValueError: # for py<3.5\n except json.JSONDecodeError: # for py>=3.5\n try:\n data = yaml.load(_data, Loader=yaml.SafeLoader)\n except (yaml.scanner.ScannerError, yaml.parser.ParserError):\n raise ValueError(\"Not a valid JSON or YAML format.\")\n return data","def load_json_or_yaml(file_path):\n # handle json doc\n if isinstance(file_path, dict):\n return file_path\n # handle url\n if isinstance(file_path, str) and file_path.startswith(\"http\"):\n with requests.get(file_path) as url:\n # check if http requests returns a success status code\n if url.status_code != 200:\n raise ValueError(\"Invalid URL!\")\n _data = url.content\n # handle file path\n else:\n try:\n with open(str(file_path)) as f:\n _data = f.read()\n except FileNotFoundError:\n raise ValueError(\"Invalid File Path!\")\n try:\n if isinstance(_data, bytes):\n _data = _data.decode('utf-8')\n data = json.loads(_data)\n except json.JSONDecodeError: # for py>=3.5\n try:\n data = yaml.load(_data, Loader=yaml.SafeLoader)\n except (yaml.scanner.ScannerError,\n yaml.parser.ParserError):\n raise ValueError(\"Not a valid JSON or YAML format.\")\n return data","def loadOrRun(filename,function,*args):\r\n def loadJSON(filename):\r\n \"saves the data object as a JSON string\"\r\n with open(filename,\"r\") as openFile:\r\n data = json.loads(openFile.read())\r\n return data\r\n\r\n def saveJSON(filename,data):\r\n \"saves the data object as a JSON string\"\r\n with open(filename,\"w\") as openFile:\r\n openFile.write(json.dumps(data))\r\n try:\r\n data = loadJSON(filename)\r\n except IOError:\r\n data = function(*args)\r\n saveJSON(filename,data)\r\n\r\n return data","def load_json(filepath: str):\n if not filepath:\n return None\n\n abs_path = _resolve_relative_path(filepath)\n with open(abs_path) as f:\n raw_json = f.read()\n\n return json.loads(raw_json)","def load_data_file(path):\n with open(path, encoding='utf-8') as f:\n return json.load(f)","def load_json(path: Path) -> Any:\n with path.open() as f:\n return json.load(f)","def load_json(file_name):\n with open(file_name) as f:\n data = json.load(f)\n\n return data","def _json_read(filename):\n with open(filename) as file:\n return json.load(file)","def load(self, path):\n with open(path, \"rt\") as open_file:\n data = json.load(open_file)\n return data","def load_json(filename: str):\n filepath = get_file_path(filename)\n\n if filepath.exists():\n with open(filepath, mode=\"r\", encoding=\"UTF-8\") as f:\n data = json.load(f)\n return data\n else:\n save_json(filename, {})\n return {}","def get_data():\n try:\n with open('./data.json') as data_file:\n return json.load(data_file)\n except:\n data_json = json.loads('{\"message\": \"Error with file data.json\", \"success\": false}')\n return data_json","def load_from_json_file(filename):\n if type(filename) is not str:\n return\n\n with open(filename, mode=\"r\") as file:\n return json.loads(file.read())","def load_data(filepath=None):\r\n if filepath is None:\r\n filepath = LATEST_DATA_SET_PATH\r\n\r\n with open(filepath) as file:\r\n return json.load(file)","def load_json(fpath):\n with open(fpath, \"r\") as f:\n return json.load(f)","def openJson(self):\n json_file = open(self.file, 'r')\n json_data = json_file.read()\n result = json.loads(json_data)\n return result","def read_json(filepath):\n if (filepath in _json_cache):\n return _json_cache[filepath]\n with open(filepath, 'r', encoding='utf-8') as fileinfo:\n data = json.load(fileinfo)\n _json_cache[filepath] = data\n return data","def load_json(path):\n with open(path) as data_file:\n return json.load(data_file)","def data_from_file(filename):\n with open(data_full_filename(filename)) as f:\n return json.loads(f.read())","def _loadJson(self, file):\n # TODO : Is it paranoid checking?\n if os.path.isfile(file):\n try:\n with open(file, 'r') as f:\n data = json.load(f)\n return data\n except ValueError:\n msg = \"Corrupted JSON file => %s\" % file\n # logger.error(msg)\n self._exception(200, msg)\n # return -2 # code for corrupted json file\n else:\n msg = \"File cannot be found => %s\" % file\n self._exception(201, msg)","def loadJsonFromFile(filename):\n with open(filename) as f:\n return json.loads(f.read())","def load_json(filepath: str):\n with open(filepath, \"r\", encoding=\"utf8\") as f:\n return json.loads(f.read())","def _get_data_file(self, data_path):\n\n return json.load(open(data_path))","def load_json(load_path):\n # read from path\n with open(load_path) as json_file:\n data = json.load(json_file)\n return data","def load_json_file(self, file, default_content=None):\n if os.path.isfile(file) and os.path.getsize(file):\n with open(file, \"r\", encoding=\"utf-8\") as f:\n return json.load(f)\n return default_content","def load_data(fname):\n # load the json in gzip format\n with gzip.open(fname, 'r') as fin:\n data = json.loads(fin.read().decode('utf-8'))\n return data","def load_file(file_path, graceful=False):\n try:\n with open(file_path) as data_file:\n json_obj = json.load(data_file)\n logging.debug(\"Loaded JSON file from '{0}'\".format(file_path))\n except IOError:\n if graceful:\n json_obj = []\n else:\n logging.error(\"¯\\_(ツ)_/¯ There is no such file: '{0}'\".format(file_path))\n sys.exit(1)\n except ValueError:\n logging.error(\"¯\\_(ツ)_/¯ That's not JSON at all! '{0}'\".format(file_path))\n sys.exit(2)\n return json_obj","def open_data(filepath):\n\tdata = []\n\twith open(filepath) as f:\n\t data = f.readlines()\n\t data = list(map(json.loads, data)) \n\treturn data","def get_file(file):\n with open(file) as data_file:\n return json.load(data_file)","def _load(self, json_str, filepath):\n # pylint: disable=protected-access\n return self.json_o._load(json_str, filepath)","def load_from_json_file(filename):\n with open(filename, \"r\") as my_file:\n return json.loads(my_file.read())","def load_json_file(i):\n\n import json\n\n fn = i['json_file']\n\n try:\n if sys.version_info[0] > 2:\n f = open(fn, 'r', encoding='utf8')\n else:\n f = open(fn, 'r')\n except Exception as e:\n return {'return': 16, 'error': 'problem opening json file='+fn+' ('+format(e)+')'}\n\n try:\n s = f.read()\n except Exception as e:\n f.close()\n return {'return': 1, 'error': 'problem reading json file='+fn+' ('+format(e)+')'}\n\n f.close()\n\n try:\n if sys.version_info[0] > 2:\n d = json.loads(s)\n else:\n d = json.loads(s, encoding='utf8')\n except Exception as e:\n return {'return': 1, 'error': 'problem parsing json from file='+fn+' ('+format(e)+')'}\n\n return {'return': 0, 'dict': d}","def load_json(self, json_path=None):\n if json_path is None:\n json_path = self.json_path\n with open(json_path, encoding='utf-8', mode='r') as f:\n data = json.load(f)\n return data","def _json_from_file(file: IO[AnyStr]) -> Json:\n if os.path.getsize(file.name) > 0:\n return typing.cast(Json, json.load(file))\n return {}","def read_json(file_name):\n try:\n with open(file_name, \"rt\") as input_file:\n return json.loads(input_file.read())\n except TypeError:\n print(\"No valid JSON data!\")\n raise\n except IOError:\n print(\"Could not read file from disk!\")\n raise","def openFile(self, path):\n with open(path) as f:\n return json.load(f)","def load_from_json_file(filename):\n with open(filename, 'r') as f:\n obj = json.loads(f.read())\n return obj","def read_json(jsonfp):\n with JsonFile(jsonfp) as jsondata:\n return jsondata","def load(self):\n if not self.exist:\n self.create()\n\n with open(self.file_path, encoding=Config.ENCODING) as file:\n self.data = json.load(file)","def read_json(fname, check_extension=False):\n if fname is None:\n return None\n if check_extension:\n IOUtils.check_file_extensions(fname, ('.json', '.json.gz'))\n with OpenFile(fname, 'r') as fobj:\n return json.load(fobj)","def load_json(file_name_template, record_id):\n with open(file_name_template % (record_id)) as f:\n json_data = json.load(f)\n return json_data","def loadJSONFile(filename):\n\twith open(filename, 'r') as f:\n\t\treturn json.loads(f.read())","def _read_json(cls, input_file):\n with open(input_file, 'rb') as f:\n return json.load(f)","def _read_json(cls, input_file):\n with open(input_file, 'rb') as f:\n return json.load(f)","def load_from_json(file):\n with open(file, 'r') as f:\n return json.load(f)","def load_json(filename):\n with open(filename) as file:\n obj = json.load(file)\n return obj","def load_json(filepath: str):\n with open(filepath, encoding=\"utf-8\") as f:\n return json.load(f)","def read(self, filepath, dirpath=None):\n try:\n #filepath = os.path.normpath(filepath)\n with open(filepath) as f_p:\n try:\n self.json_dict = json.load(f_p)\n self.filepath = filepath\n return self.json_dict\n except ValueError as err:\n print('JSON content error in \"%s\"' % filepath)\n print(err)\n except (IOError, FileNotFoundError):\n print(\n 'Failed to open JSON file \"%s\" \"%s\"' %\n (os.path.abspath(''), filepath))\n raise NoSuchFileError(filepath)\n raise JsonContentError","def loadFromFile(self, filename):\n with open(filename, 'r') as file:\n raw_data = file.read()\n # data = json.loads(raw_data, encoding='utf-8') # python 3.9 suppression de encoding\n try:\n data = json.loads(raw_data)\n self.deserialize(data)\n self.has_been_modified = False\n except json.JSONDecodeError:\n raise InvalidFile(f'{os.path.basename(filename)} is not a valid JSON file')\n except Exception as e:\n dumpException(e)","def read_file(filename):\n with open(filename) as json_file:\n data = json.load(json_file)\n return data","def load_data(path):\r\n\r\n _, ftype = os.path.splitext(path) #get fname and extension\r\n\r\n if os.path.isfile(path):\r\n with open(path) as f:\r\n\r\n if ftype == \".json\" or ftype == \".geojson\": #handle json\r\n data = json.load(f)\r\n # print(data)\r\n return data\r\n\r\n elif ftype == \".csv\": #handle csv with csv reader\r\n with open(path, newline ='') as csvfile:\r\n data = csv.DictReader(csvfile)\r\n return list(data)\r\n\r\n else:\r\n print(\"neither json or csv\")\r\n return None","def read_json(filename: Union[pathlib.Path, str]):\n if isinstance(filename, str):\n filename = pathlib.Path(filename)\n with open(filename) as fh:\n return json.loads(fh.read())","def load_from_json_file(filename):\n with open(filename, encoding=\"utf-8\") as round:\n return json.load(round)","def readf(self, fileName):\n\t\tif os.path.exists(fileName):\n\t\t\tf = open(fileName)\n\t\t\ttry:\n\t\t\t\td = json.load(f)\n\t\t\texcept Exception as e:\n\t\t\t\tlog.error(e)\n\t\t\t\tf.close()\n\t\t\t\treturn None\n\t\t\telse:\n\t\t\t\treturn self.readd(d)\n\t\t\t\tf.close()","def util_load_json(path):\n with io.open(path, mode=\"r\", encoding=\"utf-8\") as f:\n return json.loads(f.read())","def read_json(fname):\n with open(fname) as f:\n d = json.load(f)\n return d","def load_jsondata_from_file(path, ftype=None):\n print(\"loading %s\" % path)\n t0 = time.time()\n data = []\n with open(path, 'r') as f:\n if ftype == None:\n for line in f:\n item = json.loads(line)\n data.append(item)\n elif ftype == 'user':\n for line in f:\n item = json.loads(line)\n data.append({'user_id': item['user_id'], 'friends': item['friends']})\n elif ftype == 'business':\n for line in f:\n item = json.loads(line)\n data.append({'business_id': item['business_id'], 'categories': item['categories'], 'city': item['city']})\n elif ftype == 'review':\n for line in f:\n item = json.loads(line)\n data.append({'user_id': item['user_id'], 'business_id': item['business_id'], 'stars': item['stars']})\n print(\"loading %s done, time cost %.2f\" % (path, time.time()-t0))\n return data","def read_object_from_file(file_name):\n if os.path.exists(file_name) is False:\n print (\"Error read path: [%s]\" % file_name)\n return None\n with open(file_name, 'r') as f:\n try:\n obj = json.load(f)\n except Exception:\n print (\"Error json: [%s]\" % f.read()[0:10])\n return None\n return obj","def load_from_json_file(filename):\n with open(filename, 'r') as jFile:\n fString = jFile.read()\n fObj = json.loads(fString)\n return fObj","def read_json_file(filename):\n with open(filename) as f:\n try:\n data = json.loads(f.read())\n except:\n data = {}\n return data","def load_from_json_file(filename):\n with open(filename, mode=\"r\", encoding=\"utf-8\") as a_file:\n return json.loads(a_file.read())","def read_file(path):\n with open(path) as json_file:\n data = json.load(json_file)\n return data","def load_from_json_file(filename):\n with open(filename) as f:\n return json.load(f)","def read_or_new_json(filename, value, *args, **kwargs):\n data = None\n filename = \"{}.json\".format(filename)\n os.makedirs(os.path.dirname(filename), exist_ok=True)\n\n if os.path.isfile(filename):\n # If file had been created, but is empty return None since another process\n # could be writing to it.\n if os.path.getsize(filename) > 0:\n with open(filename, \"r\") as f:\n try:\n data = json.load(f, preserve_order=False)\n except Exception as e:\n print(e)\n raise e\n else:\n if callable(value):\n data = value(*args, **kwargs)\n else:\n data = value\n with open(filename, \"w\") as f:\n json.dump(data, f, indent=4, separators=(',', ': '), sort_keys=True, allow_nan=True)\n return data","def read_json_data(data_path: str):\n f = open(data_path, \"r\")\n return json.load(f)","def _read_json(filename):\n with open(filename) as f:\n import json\n return json.load(f)","def load_json(jsonfile):\n with open(jsonfile) as f:\n return json.load(f)","def load_json(jsonfile):\n with open(jsonfile) as f:\n return json.load(f)","def read(fname):\n # Read string from JSON file.\n with open(fname, 'r') as fi:\n serial = fi.read()\n\n # Decode.\n decoder = json.JSONDecoder(object_hook=numpy_hook)\n data = decoder.decode(serial)\n\n return data","def _read_json(cls, input_file):\n with open(input_file) as f:\n return json.load(f)","def _read_json(cls, input_file):\n with open(input_file) as f:\n return json.load(f)","def read_json(filepath):\n\n with open(filepath, 'r', encoding='utf-8') as file_obj:\n data = json.load(file_obj)\n\n return data","def _remoteloadjson(path: str) -> JSONType:\n return json.loads(request.urlopen(path).read())","def load_from_json_file(filename):\n with open(filename, \"r\", encoding=\"utf-8\") as f:\n return(json.loads(f.read()))","def from_json(fname):\n with open(fname, 'r') as fh:\n d = json.load(fh)\n return d","def from_file(filename):\n # in order to complete this lab we are going to use the python lib json in which we have the function json.loads\n # which will automatically load a json from a string\n f = open(filename, 'r')\n string = f.read()\n return json.loads(string)","def __init__(self, json_str: object = None, json_file_path: object = None) -> None:\n self.data = None\n if json_str is None and json_file_path is None:\n # raise Exception(\"Invalid file path or json string. Please provide valid file path for json data or provide json string\")\n print(\"No valid json file has been loaded\")\n if json_str is None:\n with open(json_file_path) as file:\n self.data = json.load(file)\n else:\n self.data = json.loads(json_str)\n # if self.data is not None:","def read_json(fn):\n with open(fn) as f:\n return json.load(f, object_hook=_operator_object_hook)","def loader(data: Union[str, dict], _: FileInfo) -> Optional[dict]:\n if isinstance(data, str):\n if fmt != 'json-ld':\n g = Graph()\n g.parse(data=data, format=fmt)\n data = pyld_jsonld_from_rdflib_graph(g)\n\n if not isinstance(data, dict):\n # TODO: Add a context processor to the source w/ CONTEXTS_PARAM_TYPE\n # TODO: figure out what to do base options below\n # TODO: determine whether jsonld.frame can handle something other than string input\n data_as_dict = jsonld.frame(data, contexts)\n else:\n data_as_dict = data\n typ = data_as_dict.pop('@type', None)\n # TODO: remove this when we get the Biolinkml issue fixed\n if not typ:\n typ = data_as_dict.pop('type', None)\n if typ and typ != target_class.class_name:\n # TODO: connect this up with the logging facility or warning?\n print(f\"Warning: input type mismatch. Expected: {target_class.__name__}, Actual: {typ}\")\n return json_clean(data_as_dict)","def load_from_json_file(filename):\n import json\n with open(filename, 'r') as s:\n return json.load(s)"],"string":"[\n \"def _load_data_from_file(self, input_file_path):\\n with FileOrBufferHandler(input_file_path, 'r', \\n encoding=self.file_encoding) as input_file:\\n try:\\n data = json.load(input_file)\\n except (json.JSONDecodeError, UnicodeDecodeError):\\n input_file.seek(0)\\n data = data_utils.read_json(\\n data_generator=input_file,\\n selected_columns=self.selected_keys,\\n read_in_string=False\\n )\\n return data\",\n \"def load(filename):\\n\\n try:\\n with open(filename) as data:\\n return json.load(data)\\n except:\\n return None\",\n \"def _load_json_data(filename):\\n\\n relative_path = join(\\\"data\\\", filename)\\n absolute_path = join(dirname(__file__), relative_path)\\n\\n with open(absolute_path) as data_file:\\n return json.loads(data_file.read())\",\n \"def load_json_data(filepath):\\n with open(filepath,'r') as f:\\n return json.load(f)\",\n \"def __load_data(data_loc):\\n if not data_loc.endswith('.json'):\\n raise ValueError('data_loc must be a json file location.')\\n with open(data_loc, 'rb') as f:\\n return json.load(f)\",\n \"def load(file, **kwargs):\\n extension = os.path.splitext(file)\\n if extension not in {'.json', '.axjson'}:\\n raise RuntimeError('Given extension ({}) not supported'.format(extension))\\n with open(file) as f:\\n data = json.load(f)\\n if extension == '.json':\\n return data\\n else:\\n json_str = json.dumps(data)\\n return loads(json_str, **kwargs)\",\n \"def load_json(filename_or_dict):\\n\\tif isinstance(filename_or_dict, str):\\n\\t\\tinput_file = open(filename_or_dict, encoding='utf-8')\\n\\t\\tjson_dict = json.loads(input_file.read())\\n\\t\\tinput_file.close()\\n\\t\\treturn json_dict\\n\\treturn filename_or_dict\",\n \"def read_json(file_or_path):\\n try:\\n with (open(file_or_path, 'r') if isinstance(file_or_path, (str, bytes)) else file_or_path) as f:\\n obj = json.load(f)\\n except IOError:\\n obj = json.loads(file_or_path)\\n return obj\",\n \"def json_loader(filename):\\n\\n with open(filename, \\\"r\\\", encoding=\\\"UTF-8\\\") as source:\\n data = json.load(source, object_hook=object_decode)\\n return data\",\n \"def _localloadjson(path: str) -> JSONType:\\n with open(path, encoding=\\\"utf-8\\\") as fh:\\n return json.load(fh)\",\n \"def json_load(file_path):\\n\\n with open(file_path) as f:\\n return json_loads(f.read())\",\n \"def open_json(path):\\n with open(path, \\\"r\\\") as json_data_file:\\n data = json.load(json_data_file)\\n return data\",\n \"def load_json(file_name):\\n return json.load(open(file_name))\",\n \"def load_data(filename):\\n with open(filename) as json_file:\\n data = json.load(json_file)\\n return data\",\n \"def load_json(path):\\n import json\\n\\n def _load_json(*args, **kwargs):\\n with open(path) as data_file:\\n return json.load(data_file)\\n\\n return _load_json()\",\n \"def load(self):\\n data = None\\n try:\\n with open(self.__filepath, 'r') as file:\\n text = file.read()\\n data = jsonpickle.decode(text)\\n except FileNotFoundError:\\n data = None\\n except IOError as e:\\n print(e)\\n return data\",\n \"def _load(self):\\n if self.file_path.exists():\\n with open(self.file_path) as fid:\\n self.data = json.load(fid)\",\n \"def loadJSON(jsonData):\\n\\n if hasattr(jsonData, 'read'):\\n loadedjson = json.load(jsonData)\\n elif isinstance(jsonData, str):\\n if os.path.exists(jsonData):\\n with open(jsonData) as jsonFile:\\n loadedjson = json.load(jsonFile)\\n else:\\n try:\\n loadedjson = json.loads(jsonData)\\n except JSONDecodeError as e:\\n raise ValueError(f\\\" {str(e)}: Got {jsonData}, either bad format of file does not exist\\\")\\n\\n elif isinstance(jsonData, dict):\\n loadedjson = jsonData\\n else:\\n err = f\\\"workflow type: {type(jsonData)} is unknonw. Must be str, file-like or dict. \\\"\\n raise ValueError(err)\\n\\n\\n return loadedjson\",\n \"def load_json(file_path):\\n try:\\n with open(file_path, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n data = json.load(f)\\n except json.JSONDecodeError as e:\\n raise ValueError(f\\\"Invalid JSON format in file {file_path}\\\") from e\\n except FileNotFoundError as e:\\n raise ValueError(f\\\"File not found: {file_path}\\\") from e\\n return data\",\n \"def read_json(self, *args, **kwargs):\\n with self.open('rb') as f:\\n return json.load(f, *args, **kwargs)\",\n \"def json_load(fp):\\n with _iotools.open_file(fp, \\\"r\\\") as f:\\n return json.load(f, cls=DataDecoder)\",\n \"def load_json_or_yaml(file_path):\\n # handle json doc\\n if isinstance(file_path, dict):\\n return file_path\\n # handle url\\n elif file_path.startswith(\\\"http\\\"):\\n with requests.get(file_path) as url:\\n # check if http requests returns a success status code\\n if url.status_code != 200:\\n raise ValueError(f\\\"Invalid URL [{url.status_code}]: {file_path} !\\\")\\n else:\\n _data = url.content\\n # handle file path\\n else:\\n try:\\n with open(file_path) as f:\\n _data = f.read()\\n except FileNotFoundError:\\n raise ValueError(\\\"Invalid File Path!\\\")\\n try:\\n if isinstance(_data, bytes):\\n _data = _data.decode(\\\"utf-8\\\")\\n data = json.loads(_data)\\n # except ValueError: # for py<3.5\\n except json.JSONDecodeError: # for py>=3.5\\n try:\\n data = yaml.load(_data, Loader=yaml.SafeLoader)\\n except (yaml.scanner.ScannerError, yaml.parser.ParserError):\\n raise ValueError(\\\"Not a valid JSON or YAML format.\\\")\\n return data\",\n \"def load_json_or_yaml(file_path):\\n # handle json doc\\n if isinstance(file_path, dict):\\n return file_path\\n # handle url\\n if isinstance(file_path, str) and file_path.startswith(\\\"http\\\"):\\n with requests.get(file_path) as url:\\n # check if http requests returns a success status code\\n if url.status_code != 200:\\n raise ValueError(\\\"Invalid URL!\\\")\\n _data = url.content\\n # handle file path\\n else:\\n try:\\n with open(str(file_path)) as f:\\n _data = f.read()\\n except FileNotFoundError:\\n raise ValueError(\\\"Invalid File Path!\\\")\\n try:\\n if isinstance(_data, bytes):\\n _data = _data.decode('utf-8')\\n data = json.loads(_data)\\n except json.JSONDecodeError: # for py>=3.5\\n try:\\n data = yaml.load(_data, Loader=yaml.SafeLoader)\\n except (yaml.scanner.ScannerError,\\n yaml.parser.ParserError):\\n raise ValueError(\\\"Not a valid JSON or YAML format.\\\")\\n return data\",\n \"def loadOrRun(filename,function,*args):\\r\\n def loadJSON(filename):\\r\\n \\\"saves the data object as a JSON string\\\"\\r\\n with open(filename,\\\"r\\\") as openFile:\\r\\n data = json.loads(openFile.read())\\r\\n return data\\r\\n\\r\\n def saveJSON(filename,data):\\r\\n \\\"saves the data object as a JSON string\\\"\\r\\n with open(filename,\\\"w\\\") as openFile:\\r\\n openFile.write(json.dumps(data))\\r\\n try:\\r\\n data = loadJSON(filename)\\r\\n except IOError:\\r\\n data = function(*args)\\r\\n saveJSON(filename,data)\\r\\n\\r\\n return data\",\n \"def load_json(filepath: str):\\n if not filepath:\\n return None\\n\\n abs_path = _resolve_relative_path(filepath)\\n with open(abs_path) as f:\\n raw_json = f.read()\\n\\n return json.loads(raw_json)\",\n \"def load_data_file(path):\\n with open(path, encoding='utf-8') as f:\\n return json.load(f)\",\n \"def load_json(path: Path) -> Any:\\n with path.open() as f:\\n return json.load(f)\",\n \"def load_json(file_name):\\n with open(file_name) as f:\\n data = json.load(f)\\n\\n return data\",\n \"def _json_read(filename):\\n with open(filename) as file:\\n return json.load(file)\",\n \"def load(self, path):\\n with open(path, \\\"rt\\\") as open_file:\\n data = json.load(open_file)\\n return data\",\n \"def load_json(filename: str):\\n filepath = get_file_path(filename)\\n\\n if filepath.exists():\\n with open(filepath, mode=\\\"r\\\", encoding=\\\"UTF-8\\\") as f:\\n data = json.load(f)\\n return data\\n else:\\n save_json(filename, {})\\n return {}\",\n \"def get_data():\\n try:\\n with open('./data.json') as data_file:\\n return json.load(data_file)\\n except:\\n data_json = json.loads('{\\\"message\\\": \\\"Error with file data.json\\\", \\\"success\\\": false}')\\n return data_json\",\n \"def load_from_json_file(filename):\\n if type(filename) is not str:\\n return\\n\\n with open(filename, mode=\\\"r\\\") as file:\\n return json.loads(file.read())\",\n \"def load_data(filepath=None):\\r\\n if filepath is None:\\r\\n filepath = LATEST_DATA_SET_PATH\\r\\n\\r\\n with open(filepath) as file:\\r\\n return json.load(file)\",\n \"def load_json(fpath):\\n with open(fpath, \\\"r\\\") as f:\\n return json.load(f)\",\n \"def openJson(self):\\n json_file = open(self.file, 'r')\\n json_data = json_file.read()\\n result = json.loads(json_data)\\n return result\",\n \"def read_json(filepath):\\n if (filepath in _json_cache):\\n return _json_cache[filepath]\\n with open(filepath, 'r', encoding='utf-8') as fileinfo:\\n data = json.load(fileinfo)\\n _json_cache[filepath] = data\\n return data\",\n \"def load_json(path):\\n with open(path) as data_file:\\n return json.load(data_file)\",\n \"def data_from_file(filename):\\n with open(data_full_filename(filename)) as f:\\n return json.loads(f.read())\",\n \"def _loadJson(self, file):\\n # TODO : Is it paranoid checking?\\n if os.path.isfile(file):\\n try:\\n with open(file, 'r') as f:\\n data = json.load(f)\\n return data\\n except ValueError:\\n msg = \\\"Corrupted JSON file => %s\\\" % file\\n # logger.error(msg)\\n self._exception(200, msg)\\n # return -2 # code for corrupted json file\\n else:\\n msg = \\\"File cannot be found => %s\\\" % file\\n self._exception(201, msg)\",\n \"def loadJsonFromFile(filename):\\n with open(filename) as f:\\n return json.loads(f.read())\",\n \"def load_json(filepath: str):\\n with open(filepath, \\\"r\\\", encoding=\\\"utf8\\\") as f:\\n return json.loads(f.read())\",\n \"def _get_data_file(self, data_path):\\n\\n return json.load(open(data_path))\",\n \"def load_json(load_path):\\n # read from path\\n with open(load_path) as json_file:\\n data = json.load(json_file)\\n return data\",\n \"def load_json_file(self, file, default_content=None):\\n if os.path.isfile(file) and os.path.getsize(file):\\n with open(file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n return json.load(f)\\n return default_content\",\n \"def load_data(fname):\\n # load the json in gzip format\\n with gzip.open(fname, 'r') as fin:\\n data = json.loads(fin.read().decode('utf-8'))\\n return data\",\n \"def load_file(file_path, graceful=False):\\n try:\\n with open(file_path) as data_file:\\n json_obj = json.load(data_file)\\n logging.debug(\\\"Loaded JSON file from '{0}'\\\".format(file_path))\\n except IOError:\\n if graceful:\\n json_obj = []\\n else:\\n logging.error(\\\"¯\\\\_(ツ)_/¯ There is no such file: '{0}'\\\".format(file_path))\\n sys.exit(1)\\n except ValueError:\\n logging.error(\\\"¯\\\\_(ツ)_/¯ That's not JSON at all! '{0}'\\\".format(file_path))\\n sys.exit(2)\\n return json_obj\",\n \"def open_data(filepath):\\n\\tdata = []\\n\\twith open(filepath) as f:\\n\\t data = f.readlines()\\n\\t data = list(map(json.loads, data)) \\n\\treturn data\",\n \"def get_file(file):\\n with open(file) as data_file:\\n return json.load(data_file)\",\n \"def _load(self, json_str, filepath):\\n # pylint: disable=protected-access\\n return self.json_o._load(json_str, filepath)\",\n \"def load_from_json_file(filename):\\n with open(filename, \\\"r\\\") as my_file:\\n return json.loads(my_file.read())\",\n \"def load_json_file(i):\\n\\n import json\\n\\n fn = i['json_file']\\n\\n try:\\n if sys.version_info[0] > 2:\\n f = open(fn, 'r', encoding='utf8')\\n else:\\n f = open(fn, 'r')\\n except Exception as e:\\n return {'return': 16, 'error': 'problem opening json file='+fn+' ('+format(e)+')'}\\n\\n try:\\n s = f.read()\\n except Exception as e:\\n f.close()\\n return {'return': 1, 'error': 'problem reading json file='+fn+' ('+format(e)+')'}\\n\\n f.close()\\n\\n try:\\n if sys.version_info[0] > 2:\\n d = json.loads(s)\\n else:\\n d = json.loads(s, encoding='utf8')\\n except Exception as e:\\n return {'return': 1, 'error': 'problem parsing json from file='+fn+' ('+format(e)+')'}\\n\\n return {'return': 0, 'dict': d}\",\n \"def load_json(self, json_path=None):\\n if json_path is None:\\n json_path = self.json_path\\n with open(json_path, encoding='utf-8', mode='r') as f:\\n data = json.load(f)\\n return data\",\n \"def _json_from_file(file: IO[AnyStr]) -> Json:\\n if os.path.getsize(file.name) > 0:\\n return typing.cast(Json, json.load(file))\\n return {}\",\n \"def read_json(file_name):\\n try:\\n with open(file_name, \\\"rt\\\") as input_file:\\n return json.loads(input_file.read())\\n except TypeError:\\n print(\\\"No valid JSON data!\\\")\\n raise\\n except IOError:\\n print(\\\"Could not read file from disk!\\\")\\n raise\",\n \"def openFile(self, path):\\n with open(path) as f:\\n return json.load(f)\",\n \"def load_from_json_file(filename):\\n with open(filename, 'r') as f:\\n obj = json.loads(f.read())\\n return obj\",\n \"def read_json(jsonfp):\\n with JsonFile(jsonfp) as jsondata:\\n return jsondata\",\n \"def load(self):\\n if not self.exist:\\n self.create()\\n\\n with open(self.file_path, encoding=Config.ENCODING) as file:\\n self.data = json.load(file)\",\n \"def read_json(fname, check_extension=False):\\n if fname is None:\\n return None\\n if check_extension:\\n IOUtils.check_file_extensions(fname, ('.json', '.json.gz'))\\n with OpenFile(fname, 'r') as fobj:\\n return json.load(fobj)\",\n \"def load_json(file_name_template, record_id):\\n with open(file_name_template % (record_id)) as f:\\n json_data = json.load(f)\\n return json_data\",\n \"def loadJSONFile(filename):\\n\\twith open(filename, 'r') as f:\\n\\t\\treturn json.loads(f.read())\",\n \"def _read_json(cls, input_file):\\n with open(input_file, 'rb') as f:\\n return json.load(f)\",\n \"def _read_json(cls, input_file):\\n with open(input_file, 'rb') as f:\\n return json.load(f)\",\n \"def load_from_json(file):\\n with open(file, 'r') as f:\\n return json.load(f)\",\n \"def load_json(filename):\\n with open(filename) as file:\\n obj = json.load(file)\\n return obj\",\n \"def load_json(filepath: str):\\n with open(filepath, encoding=\\\"utf-8\\\") as f:\\n return json.load(f)\",\n \"def read(self, filepath, dirpath=None):\\n try:\\n #filepath = os.path.normpath(filepath)\\n with open(filepath) as f_p:\\n try:\\n self.json_dict = json.load(f_p)\\n self.filepath = filepath\\n return self.json_dict\\n except ValueError as err:\\n print('JSON content error in \\\"%s\\\"' % filepath)\\n print(err)\\n except (IOError, FileNotFoundError):\\n print(\\n 'Failed to open JSON file \\\"%s\\\" \\\"%s\\\"' %\\n (os.path.abspath(''), filepath))\\n raise NoSuchFileError(filepath)\\n raise JsonContentError\",\n \"def loadFromFile(self, filename):\\n with open(filename, 'r') as file:\\n raw_data = file.read()\\n # data = json.loads(raw_data, encoding='utf-8') # python 3.9 suppression de encoding\\n try:\\n data = json.loads(raw_data)\\n self.deserialize(data)\\n self.has_been_modified = False\\n except json.JSONDecodeError:\\n raise InvalidFile(f'{os.path.basename(filename)} is not a valid JSON file')\\n except Exception as e:\\n dumpException(e)\",\n \"def read_file(filename):\\n with open(filename) as json_file:\\n data = json.load(json_file)\\n return data\",\n \"def load_data(path):\\r\\n\\r\\n _, ftype = os.path.splitext(path) #get fname and extension\\r\\n\\r\\n if os.path.isfile(path):\\r\\n with open(path) as f:\\r\\n\\r\\n if ftype == \\\".json\\\" or ftype == \\\".geojson\\\": #handle json\\r\\n data = json.load(f)\\r\\n # print(data)\\r\\n return data\\r\\n\\r\\n elif ftype == \\\".csv\\\": #handle csv with csv reader\\r\\n with open(path, newline ='') as csvfile:\\r\\n data = csv.DictReader(csvfile)\\r\\n return list(data)\\r\\n\\r\\n else:\\r\\n print(\\\"neither json or csv\\\")\\r\\n return None\",\n \"def read_json(filename: Union[pathlib.Path, str]):\\n if isinstance(filename, str):\\n filename = pathlib.Path(filename)\\n with open(filename) as fh:\\n return json.loads(fh.read())\",\n \"def load_from_json_file(filename):\\n with open(filename, encoding=\\\"utf-8\\\") as round:\\n return json.load(round)\",\n \"def readf(self, fileName):\\n\\t\\tif os.path.exists(fileName):\\n\\t\\t\\tf = open(fileName)\\n\\t\\t\\ttry:\\n\\t\\t\\t\\td = json.load(f)\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tlog.error(e)\\n\\t\\t\\t\\tf.close()\\n\\t\\t\\t\\treturn None\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn self.readd(d)\\n\\t\\t\\t\\tf.close()\",\n \"def util_load_json(path):\\n with io.open(path, mode=\\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n return json.loads(f.read())\",\n \"def read_json(fname):\\n with open(fname) as f:\\n d = json.load(f)\\n return d\",\n \"def load_jsondata_from_file(path, ftype=None):\\n print(\\\"loading %s\\\" % path)\\n t0 = time.time()\\n data = []\\n with open(path, 'r') as f:\\n if ftype == None:\\n for line in f:\\n item = json.loads(line)\\n data.append(item)\\n elif ftype == 'user':\\n for line in f:\\n item = json.loads(line)\\n data.append({'user_id': item['user_id'], 'friends': item['friends']})\\n elif ftype == 'business':\\n for line in f:\\n item = json.loads(line)\\n data.append({'business_id': item['business_id'], 'categories': item['categories'], 'city': item['city']})\\n elif ftype == 'review':\\n for line in f:\\n item = json.loads(line)\\n data.append({'user_id': item['user_id'], 'business_id': item['business_id'], 'stars': item['stars']})\\n print(\\\"loading %s done, time cost %.2f\\\" % (path, time.time()-t0))\\n return data\",\n \"def read_object_from_file(file_name):\\n if os.path.exists(file_name) is False:\\n print (\\\"Error read path: [%s]\\\" % file_name)\\n return None\\n with open(file_name, 'r') as f:\\n try:\\n obj = json.load(f)\\n except Exception:\\n print (\\\"Error json: [%s]\\\" % f.read()[0:10])\\n return None\\n return obj\",\n \"def load_from_json_file(filename):\\n with open(filename, 'r') as jFile:\\n fString = jFile.read()\\n fObj = json.loads(fString)\\n return fObj\",\n \"def read_json_file(filename):\\n with open(filename) as f:\\n try:\\n data = json.loads(f.read())\\n except:\\n data = {}\\n return data\",\n \"def load_from_json_file(filename):\\n with open(filename, mode=\\\"r\\\", encoding=\\\"utf-8\\\") as a_file:\\n return json.loads(a_file.read())\",\n \"def read_file(path):\\n with open(path) as json_file:\\n data = json.load(json_file)\\n return data\",\n \"def load_from_json_file(filename):\\n with open(filename) as f:\\n return json.load(f)\",\n \"def read_or_new_json(filename, value, *args, **kwargs):\\n data = None\\n filename = \\\"{}.json\\\".format(filename)\\n os.makedirs(os.path.dirname(filename), exist_ok=True)\\n\\n if os.path.isfile(filename):\\n # If file had been created, but is empty return None since another process\\n # could be writing to it.\\n if os.path.getsize(filename) > 0:\\n with open(filename, \\\"r\\\") as f:\\n try:\\n data = json.load(f, preserve_order=False)\\n except Exception as e:\\n print(e)\\n raise e\\n else:\\n if callable(value):\\n data = value(*args, **kwargs)\\n else:\\n data = value\\n with open(filename, \\\"w\\\") as f:\\n json.dump(data, f, indent=4, separators=(',', ': '), sort_keys=True, allow_nan=True)\\n return data\",\n \"def read_json_data(data_path: str):\\n f = open(data_path, \\\"r\\\")\\n return json.load(f)\",\n \"def _read_json(filename):\\n with open(filename) as f:\\n import json\\n return json.load(f)\",\n \"def load_json(jsonfile):\\n with open(jsonfile) as f:\\n return json.load(f)\",\n \"def load_json(jsonfile):\\n with open(jsonfile) as f:\\n return json.load(f)\",\n \"def read(fname):\\n # Read string from JSON file.\\n with open(fname, 'r') as fi:\\n serial = fi.read()\\n\\n # Decode.\\n decoder = json.JSONDecoder(object_hook=numpy_hook)\\n data = decoder.decode(serial)\\n\\n return data\",\n \"def _read_json(cls, input_file):\\n with open(input_file) as f:\\n return json.load(f)\",\n \"def _read_json(cls, input_file):\\n with open(input_file) as f:\\n return json.load(f)\",\n \"def read_json(filepath):\\n\\n with open(filepath, 'r', encoding='utf-8') as file_obj:\\n data = json.load(file_obj)\\n\\n return data\",\n \"def _remoteloadjson(path: str) -> JSONType:\\n return json.loads(request.urlopen(path).read())\",\n \"def load_from_json_file(filename):\\n with open(filename, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n return(json.loads(f.read()))\",\n \"def from_json(fname):\\n with open(fname, 'r') as fh:\\n d = json.load(fh)\\n return d\",\n \"def from_file(filename):\\n # in order to complete this lab we are going to use the python lib json in which we have the function json.loads\\n # which will automatically load a json from a string\\n f = open(filename, 'r')\\n string = f.read()\\n return json.loads(string)\",\n \"def __init__(self, json_str: object = None, json_file_path: object = None) -> None:\\n self.data = None\\n if json_str is None and json_file_path is None:\\n # raise Exception(\\\"Invalid file path or json string. Please provide valid file path for json data or provide json string\\\")\\n print(\\\"No valid json file has been loaded\\\")\\n if json_str is None:\\n with open(json_file_path) as file:\\n self.data = json.load(file)\\n else:\\n self.data = json.loads(json_str)\\n # if self.data is not None:\",\n \"def read_json(fn):\\n with open(fn) as f:\\n return json.load(f, object_hook=_operator_object_hook)\",\n \"def loader(data: Union[str, dict], _: FileInfo) -> Optional[dict]:\\n if isinstance(data, str):\\n if fmt != 'json-ld':\\n g = Graph()\\n g.parse(data=data, format=fmt)\\n data = pyld_jsonld_from_rdflib_graph(g)\\n\\n if not isinstance(data, dict):\\n # TODO: Add a context processor to the source w/ CONTEXTS_PARAM_TYPE\\n # TODO: figure out what to do base options below\\n # TODO: determine whether jsonld.frame can handle something other than string input\\n data_as_dict = jsonld.frame(data, contexts)\\n else:\\n data_as_dict = data\\n typ = data_as_dict.pop('@type', None)\\n # TODO: remove this when we get the Biolinkml issue fixed\\n if not typ:\\n typ = data_as_dict.pop('type', None)\\n if typ and typ != target_class.class_name:\\n # TODO: connect this up with the logging facility or warning?\\n print(f\\\"Warning: input type mismatch. Expected: {target_class.__name__}, Actual: {typ}\\\")\\n return json_clean(data_as_dict)\",\n \"def load_from_json_file(filename):\\n import json\\n with open(filename, 'r') as s:\\n return json.load(s)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74808633","0.7463258","0.7429995","0.7426092","0.73366517","0.72446245","0.7234326","0.7181051","0.7129091","0.71012217","0.7058075","0.70502263","0.7007759","0.6973326","0.69674516","0.6960993","0.69258857","0.69136333","0.6907644","0.6902104","0.6878441","0.6876933","0.6873137","0.6860294","0.6859","0.6850668","0.6839429","0.6829113","0.6825724","0.68229425","0.68141276","0.679877","0.67983663","0.67732304","0.6765584","0.67576617","0.67250216","0.6724055","0.6722727","0.6722316","0.6717097","0.67163146","0.6710104","0.6700374","0.669439","0.6690857","0.6675834","0.66725093","0.66709954","0.6670464","0.6668725","0.66638774","0.6652164","0.66473323","0.6644527","0.6641803","0.66414905","0.6634641","0.6632855","0.6620538","0.661893","0.66173154","0.6615846","0.6615846","0.66036123","0.6602922","0.659314","0.6591999","0.65877664","0.6585453","0.65722984","0.6570041","0.65650356","0.65617096","0.6556709","0.6556427","0.65559596","0.6546881","0.65331835","0.6519233","0.65154487","0.6514032","0.6512435","0.6506935","0.65040886","0.65037715","0.6498708","0.6498708","0.64934176","0.64930975","0.64930975","0.64864707","0.64762086","0.64756167","0.6475604","0.6475167","0.6473566","0.6465799","0.64584994","0.6441749"],"string":"[\n \"0.74808633\",\n \"0.7463258\",\n \"0.7429995\",\n \"0.7426092\",\n \"0.73366517\",\n \"0.72446245\",\n \"0.7234326\",\n \"0.7181051\",\n \"0.7129091\",\n \"0.71012217\",\n \"0.7058075\",\n \"0.70502263\",\n \"0.7007759\",\n \"0.6973326\",\n \"0.69674516\",\n \"0.6960993\",\n \"0.69258857\",\n \"0.69136333\",\n \"0.6907644\",\n \"0.6902104\",\n \"0.6878441\",\n \"0.6876933\",\n \"0.6873137\",\n \"0.6860294\",\n \"0.6859\",\n \"0.6850668\",\n \"0.6839429\",\n \"0.6829113\",\n \"0.6825724\",\n \"0.68229425\",\n \"0.68141276\",\n \"0.679877\",\n \"0.67983663\",\n \"0.67732304\",\n \"0.6765584\",\n \"0.67576617\",\n \"0.67250216\",\n \"0.6724055\",\n \"0.6722727\",\n \"0.6722316\",\n \"0.6717097\",\n \"0.67163146\",\n \"0.6710104\",\n \"0.6700374\",\n \"0.669439\",\n \"0.6690857\",\n \"0.6675834\",\n \"0.66725093\",\n \"0.66709954\",\n \"0.6670464\",\n \"0.6668725\",\n \"0.66638774\",\n \"0.6652164\",\n \"0.66473323\",\n \"0.6644527\",\n \"0.6641803\",\n \"0.66414905\",\n \"0.6634641\",\n \"0.6632855\",\n \"0.6620538\",\n \"0.661893\",\n \"0.66173154\",\n \"0.6615846\",\n \"0.6615846\",\n \"0.66036123\",\n \"0.6602922\",\n \"0.659314\",\n \"0.6591999\",\n \"0.65877664\",\n \"0.6585453\",\n \"0.65722984\",\n \"0.6570041\",\n \"0.65650356\",\n \"0.65617096\",\n \"0.6556709\",\n \"0.6556427\",\n \"0.65559596\",\n \"0.6546881\",\n \"0.65331835\",\n \"0.6519233\",\n \"0.65154487\",\n \"0.6514032\",\n \"0.6512435\",\n \"0.6506935\",\n \"0.65040886\",\n \"0.65037715\",\n \"0.6498708\",\n \"0.6498708\",\n \"0.64934176\",\n \"0.64930975\",\n \"0.64930975\",\n \"0.64864707\",\n \"0.64762086\",\n \"0.64756167\",\n \"0.6475604\",\n \"0.6475167\",\n \"0.6473566\",\n \"0.6465799\",\n \"0.64584994\",\n \"0.6441749\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7064134"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":4492,"cells":{"query":{"kind":"string","value":"Get the schema for the given strand."},"document":{"kind":"string","value":"def _get_schema(self, strand):\n if strand == \"twine\":\n # The data is a twine. A twine *contains* schema, but we also need to verify that it matches a certain\n # schema itself. The twine schema is distributed with this packaged to ensure version consistency...\n schema_path = \"schema/twine_schema.json\"\n\n elif strand in CHILDREN_STRANDS:\n # The data is a list of children. The \"children\" strand of the twine describes matching criteria for\n # the children, not the schema of the \"children\" data, which is distributed with this package to ensure\n # version consistency...\n schema_path = \"schema/children_schema.json\"\n\n elif strand in MANIFEST_STRANDS:\n # The data is a manifest of files. The \"*_manifest\" strands of the twine describe matching criteria used to\n # filter files appropriate for consumption by the digital twin, not the schema of the manifest data, which\n # is distributed with this package to ensure version consistency...\n schema_path = \"schema/manifest_schema.json\"\n\n else:\n if strand not in SCHEMA_STRANDS:\n raise exceptions.UnknownStrand(f\"Unknown strand {strand}. Try one of {ALL_STRANDS}.\")\n\n # Get schema from twine.json file.\n schema_key = strand + \"_schema\"\n\n try:\n return getattr(self, schema_key)\n except AttributeError:\n raise exceptions.StrandNotFound(f\"Cannot validate - no {schema_key} strand in the twine\")\n\n return jsonlib.loads(pkg_resources.resource_string(\"twined\", schema_path))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _get_schema(self):\n self._pick()\n return Schema()","def _get_schema_using_query(self, query: str) -> sch.Schema:\n return sch.Schema.from_tuples(self._metadata(query))","def schema(self):\n return _parse_schema_resource(self._properties.get(\"schema\", {}))","def get_schema(cls):\n return cls.schema()","def get_schema(self):\n response = self.client.get(self._get_collection_url('schema'))\n\n return response.get('schema', {})","def get_schema(): # noqa: WPS440\n return config.DEFAULT_SCHEMA","def get_schema(self) -> ArchiveSchema:\n return self.schema","def get_schema(self):\r\n return self.__schema","def sample_schema(self):\n if 'sample' not in self._schemas:\n logging.debug(f\"{self.id} - no schema? {self._schemas}\")\n return None\n return self._schemas['sample']","def getSchema(cls):\n pass","def schema(cls):\n return Schema.get_instance(cls)","def get_schema(schema): # noqa: E501\n return 'do some magic!'","def get_schema():\n if TEST_COLLECTION:\n return TestSchema()\n return MySchema()","def getSchema( sourceDirectory ):\r\n if( sourceDirectory == settings.LEXISNEXIS_FILETAG ): return LexisNexisSchema()\r\n raise Exception( \"Filer for source <%s> is not registered in getSchema( source ).\" % ( sourceDirectory ) )","def get_schema():\n if not os.path.isfile(_schema_file):\n create_schema()\n with open(_schema_file, 'r') as fd:\n out = decode_json(fd)\n return out","def get_schema(self) -> dict:","async def get_schema(request: Request, namespace: str, project: str):\n # endpoint to schema.databio.org/...\n # like pipelines/ProseqPEP.yaml\n\n try:\n schema = eido.read_schema(\n f\"https://schema.databio.org/{namespace}/{project}.yaml\"\n )[0]\n except IndexError:\n raise HTTPException(status_code=404, detail=\"Schema not found\")\n\n return schema","def get_schema(self, engine_name):\n endpoint = \"engines/{}/schema\".format(engine_name)\n return self.swiftype_session.request('get', endpoint)","def get_schema(self, name):\n return Schema(self, name)","def get_schema(self) -> dict:\n return schemas.get_object_schema(self.schema)","def schema(self, name):\n return model.Schema(self, name)","def _get_schema(name):\n global SCHEMA\n\n loaded_schema = SCHEMA.get(name)\n if not loaded_schema:\n filename = \"{}/{}.json\".format(_get_directory(), name)\n if os.path.exists(filename):\n SCHEMA[name] = json.load(open(filename, 'r'))\n\n return SCHEMA.get(name)","def schema(self) -> 'outputs.TableSchemaResponse':\n return pulumi.get(self, \"schema\")","def schema(self):\n return self._schema","def schema(self) -> str:\n return parse_schema(self._spec[\"schema\"])","def getDBSchema(self, desired=None):\n role = self.getRole(desired)\n schema = role[\"roleName\"]\n return schema","def _get_schema(want_version):\n for maj, min in _GET_SCHEMA_MICROVERSIONS:\n if want_version.matches((maj, min)):\n return getattr(schema, 'GET_SCHEMA_%d_%d' % (maj, min))\n\n return schema.GET_SCHEMA_1_10","def schema(self):\n # type: () -> object\n return self._schema","def get_default_schema(self):\n schema = self._connection.settings.get(\"schema\")\n if schema:\n res = (\n self.sql(_SELECT_SCHEMA_NAME_QUERY.format(escape(schema)))\n .execute()\n .fetch_all()\n )\n try:\n if res[0][0] == schema:\n return Schema(self, schema)\n except IndexError:\n raise ProgrammingError(\n f\"Default schema '{schema}' does not exists\"\n ) from None\n return None","def get_schema(sid, did, scid):\n\n driver = get_driver(PG_DEFAULT_DRIVER)\n manager = driver.connection_manager(sid)\n conn = manager.connection(did=did)\n\n ver = manager.version\n server_type = manager.server_type\n\n # Fetch schema name\n status, schema_name = conn.execute_scalar(\n render_template(\n \"/\".join(['schemas',\n '{0}/#{1}#'.format(server_type, ver),\n 'sql/get_name.sql']),\n conn=conn, scid=scid\n )\n )\n\n return status, schema_name","def get_schema(db, sourcename):\n try:\n schema = db[\"tables\"][sourcename]\n schema[\"type\"] = constants.TABLE\n except KeyError:\n try:\n schema = db[\"views\"][sourcename]\n schema[\"type\"] = constants.VIEW\n except KeyError:\n raise ValueError(\"no such table/view\")\n return schema","def get_bundled_schema_path():\n return str(data.load_resource(\"schema\"))","def _schema_type(self) -> Optional[type]:\n return SeriesSchema","def schema_for_config(self) -> Dict[str, Any]:\n return self.rsimulator.schema_for_config()","def get_schema_defs():\n return SCHEMA_DEFS","def __getitem__(self, name) -> 'StarSchema':\n return self.schemas[name]","def load_dde_schemas(self, schema):\n if self.verbose:\n print(f'Loading registered DDE schema \"{schema}\"')\n schema_source = schemas.get(schema)\n schema_source.pop(\"_id\")\n return schema_source","def schema(self) -> Schema:\n return next(schema for schema in self.metadata.schemas if schema.schema_id == self.metadata.current_schema_id)","def _schema_type(self) -> Optional[type]:\n return IndexSchema","def schema() -> None:\n pass","def sbi_schema():\n schema_path = os.path.join(os.path.dirname(__file__), '..', '..',\n 'scheduling', 'schema',\n 'configure_sbi.json')\n with open(schema_path, 'r') as file:\n schema_data = file.read()\n return json.loads(schema_data)","async def get_schema(self) -> AvroSchemaT:\n schema = None\n try:\n schema = await self._client.schema_by_topic(self._subject)\n except Exception:\n msg = f\"Could not retrieve schema for subject {self._subject}.\"\n raise SchemaException(msg)\n\n return schema","def schema_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"schema_name\")","def get_docname_from_schema(doctype,config):\n\tfor coll in config[\"schema\"].keys():\n\t\tfor doc in config[\"schema\"][coll].keys():\n\t\t\tif doctype == doc: return config[\"schema\"][coll][doc]","def get_schema() -> dict:\n raise NotImplementedError()","def create_schema(self, schema: str):\n return","def namespace_schema(self, namespace):\n try:\n return self._namespace_schemas[namespace]\n except KeyError:\n raise Error(\"undefined namespace: \\\"%s\\\"; defined namespaces: %s\" % (namespace, util.quoted_list(self._namespace_schemas.keys())))","def schema(self):\n return self.snowflake_options.schema","def get_schema_cls() -> t.Any:\n return SignupRequestSchema","def _get_stored_schema(self, table: str) -> Optional[TableSchema]:\n try:\n with open(self.schemas / (table + '.json'), 'r') as f:\n return json.load(f)\n except FileNotFoundError:\n return None","def _schema_type(self) -> Optional[type]:\n return SearchMetaSchema","def schema(self) -> Dict[str, Dict]:\n return self._schema","def _schema_type(self) -> Optional[type]:\n return SeasonSchema","def output_schema(self) -> Optional[str]:\n return pulumi.get(self, \"output_schema\")","async def get_schema(\n self, refresh: bool = False, headers: Optional[Dict[str, str]] = None\n ) -> graphql.GraphQLSchema:\n # TODO: consider adding ttl logic for expiring schemas for long running services\n if self._schema is None or refresh:\n self._schema = await self.introspect(headers=headers)\n return self._schema","def resolver(schema):\n name = schema.__name__\n if name.endswith(\"Schema\"):\n return name[:-6] or name\n return name","def get_schema(self, get_stats=False):\n query = \"schema {}\"\n\n results = self.run_dgraph_query_raw(query)\n\n schema = {}\n\n for row in results[\"schema\"]:\n table_name = row[\"predicate\"]\n\n if table_name not in schema:\n schema[table_name] = {\"name\": table_name, \"columns\": []}\n\n return list(schema.values())","def full_schema_list(self, schema: str) -> List[str]:\n # Generate the information_schema identifier for that database\n # in order to be able to filter it out\n name_parts = schema.split(\".\")\n\n info_schema = f\"{name_parts[0]}.information_schema\"\n\n fetched_schemas = []\n\n # All Schemas\n if name_parts[1] == \"*\":\n db_schemas = self.show_schemas(name_parts[0])\n for db_schema in db_schemas:\n if db_schema != info_schema:\n fetched_schemas.append(db_schema)\n\n # Prefix schema match\n elif \"*\" in name_parts[1]:\n db_schemas = self.show_schemas(name_parts[0])\n for db_schema in db_schemas:\n schema_name = db_schema.split(\".\", 1)[1].lower()\n if schema_name.startswith(name_parts[1].split(\"*\", 1)[0]):\n fetched_schemas.append(db_schema)\n\n # TODO Handle more complicated matches\n\n else:\n # If no * in name, then return provided schema name\n fetched_schemas = [schema]\n\n return fetched_schemas","def load_dde_schemas(self, schema):\n url = DDE_SCHEMA_BASE_URL + schema\n if self.verbose:\n print(f'Loading registered DDE schema from \"{url}\"')\n return load_json_or_yaml(url)[\"source\"]","def create_schema():\n schema = Schema(idx=ID(stored=True),\n data=STORED,\n body=TEXT(analyzer=StemmingAnalyzer()),\n )\n print(\"schema creation successful\")\n return schema","def schema(self):\n pass","def schema(self) -> graphql.GraphQLSchema:\n return self._schema","def schema(self):\n raise NotImplementedError","def get_schema(path):\n with open(path, 'r') as f:\n return json.load(f)","def schemas(self):\n return model.Schemas(self)","def schema_for_state(self) -> Dict[str, Any]:\n return self.rsimulator.schema_for_state()","def get_schemas(self):\n query = mssqlqueries.get_schemas()\n logger.info(u'Schemas query: %s', query)\n for tabular_result in self.execute_query(query):\n return [x[0] for x in tabular_result[0]]","def get_schema(self, repo, table):\n return self.user_con.get_schema(repo=repo, table=table)","def _schema_type(self) -> Optional[type]:\n return PanelSchema","def schemas(self):\n return self.get_schemas()","def getSchema(self):\n\n schema = [\n \"title\",\n \"body\",\n \"created_at\",\n \"id\",\n \"summary\",\n \"abstract\",\n \"keywords\",\n ]\n\n return schema","def schemas(self):\n if not self._schemas:\n self._schemas = get_schema(self.attributes.workspace.namespace, self.attributes.workspace.name)\n return self._schemas","def schema(self) -> Optional[TensorDatasetSchema]:\n try:\n features_schema = _infer_schema(self._features)\n targets_schema = None\n if self._targets is not None:\n targets_schema = _infer_schema(self._targets)\n return TensorDatasetSchema(features=features_schema, targets=targets_schema)\n except Exception as e:\n _logger.warning(\"Failed to infer schema for NumPy dataset. Exception: %s\", e)\n return None","def get_schema_cls() -> t.Any:\n return None","def _schema_type(self) -> Optional[type]:\n return SeriesPanelMetaSchema","def get_schema_url(self):\n return self.NAME_TYPE_SCHEMAS.get(self.name_type, None)","def _schema_type(self) -> Optional[type]:\n return AdBreakSchema","def schema_helper(self, name, _, schema=None, **kwargs):\n if schema is None:\n return None\n\n schema_instance = resolve_schema_instance(schema)\n\n schema_key = make_schema_key(schema_instance)\n self.warn_if_schema_already_in_spec(schema_key)\n self.openapi.refs[schema_key] = name\n\n json_schema = self.openapi.schema2jsonschema(schema_instance)\n\n return json_schema","def schema(self):\n schema_el = self.root.xpath(\n '/wsdl:definitions/wsdl:types/xsd:schema', namespaces=NS_MAP,\n )[0]\n return element_as_tree(schema_el)","def reference_schema(self) -> pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaArgs']:\n return pulumi.get(self, \"reference_schema\")","def _schema(self):\n\n self._check_compiled()\n return self._compiled._schema","def schema(self):\n return self.table_info.schema","def get_local_schema(self, descriptor):\n return self._schemas[descriptor]['local']","def schema(self):","def serializeSchema(schema):\n\n # determine portal_type\n try:\n prefix, portal_type, schemaName = splitSchemaName(schema.__name__)\n except ValueError:\n # not a dexterity schema\n return\n\n # find the FTI and model\n fti = queryUtility(IDexterityFTI, name=portal_type)\n if fti.model_source:\n model = fti.lookupModel()\n\n # synchronize changes to the model\n syncSchema(schema, model.schemata[schemaName], overwrite=True)\n fti.model_source = serializeModel(model)\n else:\n raise TypeError(\"Changes to non-dynamic schemata not yet supported.\")","def parse_schema_from_string(schema_str):\n return schema.Parse(schema_str)","def get_meta_schema(self):\n return self._tc_meta_schema","def _schema_type(self) -> Optional[type]:\n return MovieSchema","def readjamschema(schema):\n raise NotImplementedError(msg)","def discover_schema(node):\n xmlns = node.get('__xmlns__', None)\n\n if xmlns:\n node['Schema'] = 'Unknown'\n if xmlns.startswith('smpte_stereo'):\n node['Schema'] = 'SMPTE Stereoscopic'\n elif xmlns.startswith('smpte'):\n node['Schema'] = 'SMPTE'\n elif xmlns.startswith('interop'):\n node['Schema'] = 'Interop'\n elif xmlns.startswith('atmos'):\n node['Schema'] = 'Atmos'","def _get_schema_from_object(self, data):\n if \"items\" in data:\n return self._get_schema_from_object(data[\"items\"])\n\n url_key = None\n\n if '$id' in data:\n url_key = '$id'\n\n if 'id' in data:\n url_key = 'id'\n\n if url_key:\n url = data[url_key]\n schema = Schema().build()\n schema.domain_entity = self.get_domain_entity_from_url(url)\n schema.high_level_entity = self.get_high_level_entity_from_url(url)\n schema.module = self.get_module_from_url(url)\n schema.url = url\n return schema\n\n return None","def getSchema(self, fp_id: int) -> Dict:\n # Identify the format\n formatquery = (\n \"\"\"select file_format from file_pattern_detail where fp_id = {0}\"\"\".format(\n fp_id\n )\n )\n formattype = self.getDataAsDict(formatquery)[0]\n if formattype[\"file_format\"] == \"DELIMITED\":\n schemaQuery = \"\"\"\n select col_name,\n col_datatype,\n col_ordinal,\n primary_key_pos,\n is_defining_col,\n is_audit_col\n from delimited_col_detail where fp_detail_id = {}\n \"\"\".format(\n fp_id\n )\n data = self.getDataAsDict(schemaQuery)\n return data","def schema_xml(self):\n return self.properties.get('SchemaXml', None)","def load_schema(schema_path):\n with open(schema_path) as schema_file:\n return Utils.parse(schema_file.read())","def _schema_type(self) -> Optional[type]:\n return SigningPolicySchema","def _validate_against_schema(self, strand, data):\n schema = self._get_schema(strand)\n\n try:\n jsonschema_validate(instance=data, schema=schema)\n logger.debug(\"Validated %s against schema\", strand)\n\n except ValidationError as e:\n raise exceptions.invalid_contents_map[strand](str(e))","def get_schemas(self, conn):\n return conn.get_schemas()['table_schema']","def _get_schema(self):\n self.to_dask()\n return Schema(dtype=self._df.dtypes,\n shape=(None, len(self._df.columns)),\n npartitions=self._df.npartitions,\n metadata=self.metadata)","def get_schema_structure(self) -> SchemaStructure:\n constructors: List[CombinatorData] = list(\n self._combinator_map.values()\n )\n methods: List[FunctionData] = list(\n self._function_map.values()\n )\n\n return SchemaStructure(constructors=constructors, methods=methods)","def JSONSchema(self, default=None):\n return self.data.get('metadata', {}).get('$schema', default)"],"string":"[\n \"def _get_schema(self):\\n self._pick()\\n return Schema()\",\n \"def _get_schema_using_query(self, query: str) -> sch.Schema:\\n return sch.Schema.from_tuples(self._metadata(query))\",\n \"def schema(self):\\n return _parse_schema_resource(self._properties.get(\\\"schema\\\", {}))\",\n \"def get_schema(cls):\\n return cls.schema()\",\n \"def get_schema(self):\\n response = self.client.get(self._get_collection_url('schema'))\\n\\n return response.get('schema', {})\",\n \"def get_schema(): # noqa: WPS440\\n return config.DEFAULT_SCHEMA\",\n \"def get_schema(self) -> ArchiveSchema:\\n return self.schema\",\n \"def get_schema(self):\\r\\n return self.__schema\",\n \"def sample_schema(self):\\n if 'sample' not in self._schemas:\\n logging.debug(f\\\"{self.id} - no schema? {self._schemas}\\\")\\n return None\\n return self._schemas['sample']\",\n \"def getSchema(cls):\\n pass\",\n \"def schema(cls):\\n return Schema.get_instance(cls)\",\n \"def get_schema(schema): # noqa: E501\\n return 'do some magic!'\",\n \"def get_schema():\\n if TEST_COLLECTION:\\n return TestSchema()\\n return MySchema()\",\n \"def getSchema( sourceDirectory ):\\r\\n if( sourceDirectory == settings.LEXISNEXIS_FILETAG ): return LexisNexisSchema()\\r\\n raise Exception( \\\"Filer for source <%s> is not registered in getSchema( source ).\\\" % ( sourceDirectory ) )\",\n \"def get_schema():\\n if not os.path.isfile(_schema_file):\\n create_schema()\\n with open(_schema_file, 'r') as fd:\\n out = decode_json(fd)\\n return out\",\n \"def get_schema(self) -> dict:\",\n \"async def get_schema(request: Request, namespace: str, project: str):\\n # endpoint to schema.databio.org/...\\n # like pipelines/ProseqPEP.yaml\\n\\n try:\\n schema = eido.read_schema(\\n f\\\"https://schema.databio.org/{namespace}/{project}.yaml\\\"\\n )[0]\\n except IndexError:\\n raise HTTPException(status_code=404, detail=\\\"Schema not found\\\")\\n\\n return schema\",\n \"def get_schema(self, engine_name):\\n endpoint = \\\"engines/{}/schema\\\".format(engine_name)\\n return self.swiftype_session.request('get', endpoint)\",\n \"def get_schema(self, name):\\n return Schema(self, name)\",\n \"def get_schema(self) -> dict:\\n return schemas.get_object_schema(self.schema)\",\n \"def schema(self, name):\\n return model.Schema(self, name)\",\n \"def _get_schema(name):\\n global SCHEMA\\n\\n loaded_schema = SCHEMA.get(name)\\n if not loaded_schema:\\n filename = \\\"{}/{}.json\\\".format(_get_directory(), name)\\n if os.path.exists(filename):\\n SCHEMA[name] = json.load(open(filename, 'r'))\\n\\n return SCHEMA.get(name)\",\n \"def schema(self) -> 'outputs.TableSchemaResponse':\\n return pulumi.get(self, \\\"schema\\\")\",\n \"def schema(self):\\n return self._schema\",\n \"def schema(self) -> str:\\n return parse_schema(self._spec[\\\"schema\\\"])\",\n \"def getDBSchema(self, desired=None):\\n role = self.getRole(desired)\\n schema = role[\\\"roleName\\\"]\\n return schema\",\n \"def _get_schema(want_version):\\n for maj, min in _GET_SCHEMA_MICROVERSIONS:\\n if want_version.matches((maj, min)):\\n return getattr(schema, 'GET_SCHEMA_%d_%d' % (maj, min))\\n\\n return schema.GET_SCHEMA_1_10\",\n \"def schema(self):\\n # type: () -> object\\n return self._schema\",\n \"def get_default_schema(self):\\n schema = self._connection.settings.get(\\\"schema\\\")\\n if schema:\\n res = (\\n self.sql(_SELECT_SCHEMA_NAME_QUERY.format(escape(schema)))\\n .execute()\\n .fetch_all()\\n )\\n try:\\n if res[0][0] == schema:\\n return Schema(self, schema)\\n except IndexError:\\n raise ProgrammingError(\\n f\\\"Default schema '{schema}' does not exists\\\"\\n ) from None\\n return None\",\n \"def get_schema(sid, did, scid):\\n\\n driver = get_driver(PG_DEFAULT_DRIVER)\\n manager = driver.connection_manager(sid)\\n conn = manager.connection(did=did)\\n\\n ver = manager.version\\n server_type = manager.server_type\\n\\n # Fetch schema name\\n status, schema_name = conn.execute_scalar(\\n render_template(\\n \\\"/\\\".join(['schemas',\\n '{0}/#{1}#'.format(server_type, ver),\\n 'sql/get_name.sql']),\\n conn=conn, scid=scid\\n )\\n )\\n\\n return status, schema_name\",\n \"def get_schema(db, sourcename):\\n try:\\n schema = db[\\\"tables\\\"][sourcename]\\n schema[\\\"type\\\"] = constants.TABLE\\n except KeyError:\\n try:\\n schema = db[\\\"views\\\"][sourcename]\\n schema[\\\"type\\\"] = constants.VIEW\\n except KeyError:\\n raise ValueError(\\\"no such table/view\\\")\\n return schema\",\n \"def get_bundled_schema_path():\\n return str(data.load_resource(\\\"schema\\\"))\",\n \"def _schema_type(self) -> Optional[type]:\\n return SeriesSchema\",\n \"def schema_for_config(self) -> Dict[str, Any]:\\n return self.rsimulator.schema_for_config()\",\n \"def get_schema_defs():\\n return SCHEMA_DEFS\",\n \"def __getitem__(self, name) -> 'StarSchema':\\n return self.schemas[name]\",\n \"def load_dde_schemas(self, schema):\\n if self.verbose:\\n print(f'Loading registered DDE schema \\\"{schema}\\\"')\\n schema_source = schemas.get(schema)\\n schema_source.pop(\\\"_id\\\")\\n return schema_source\",\n \"def schema(self) -> Schema:\\n return next(schema for schema in self.metadata.schemas if schema.schema_id == self.metadata.current_schema_id)\",\n \"def _schema_type(self) -> Optional[type]:\\n return IndexSchema\",\n \"def schema() -> None:\\n pass\",\n \"def sbi_schema():\\n schema_path = os.path.join(os.path.dirname(__file__), '..', '..',\\n 'scheduling', 'schema',\\n 'configure_sbi.json')\\n with open(schema_path, 'r') as file:\\n schema_data = file.read()\\n return json.loads(schema_data)\",\n \"async def get_schema(self) -> AvroSchemaT:\\n schema = None\\n try:\\n schema = await self._client.schema_by_topic(self._subject)\\n except Exception:\\n msg = f\\\"Could not retrieve schema for subject {self._subject}.\\\"\\n raise SchemaException(msg)\\n\\n return schema\",\n \"def schema_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"schema_name\\\")\",\n \"def get_docname_from_schema(doctype,config):\\n\\tfor coll in config[\\\"schema\\\"].keys():\\n\\t\\tfor doc in config[\\\"schema\\\"][coll].keys():\\n\\t\\t\\tif doctype == doc: return config[\\\"schema\\\"][coll][doc]\",\n \"def get_schema() -> dict:\\n raise NotImplementedError()\",\n \"def create_schema(self, schema: str):\\n return\",\n \"def namespace_schema(self, namespace):\\n try:\\n return self._namespace_schemas[namespace]\\n except KeyError:\\n raise Error(\\\"undefined namespace: \\\\\\\"%s\\\\\\\"; defined namespaces: %s\\\" % (namespace, util.quoted_list(self._namespace_schemas.keys())))\",\n \"def schema(self):\\n return self.snowflake_options.schema\",\n \"def get_schema_cls() -> t.Any:\\n return SignupRequestSchema\",\n \"def _get_stored_schema(self, table: str) -> Optional[TableSchema]:\\n try:\\n with open(self.schemas / (table + '.json'), 'r') as f:\\n return json.load(f)\\n except FileNotFoundError:\\n return None\",\n \"def _schema_type(self) -> Optional[type]:\\n return SearchMetaSchema\",\n \"def schema(self) -> Dict[str, Dict]:\\n return self._schema\",\n \"def _schema_type(self) -> Optional[type]:\\n return SeasonSchema\",\n \"def output_schema(self) -> Optional[str]:\\n return pulumi.get(self, \\\"output_schema\\\")\",\n \"async def get_schema(\\n self, refresh: bool = False, headers: Optional[Dict[str, str]] = None\\n ) -> graphql.GraphQLSchema:\\n # TODO: consider adding ttl logic for expiring schemas for long running services\\n if self._schema is None or refresh:\\n self._schema = await self.introspect(headers=headers)\\n return self._schema\",\n \"def resolver(schema):\\n name = schema.__name__\\n if name.endswith(\\\"Schema\\\"):\\n return name[:-6] or name\\n return name\",\n \"def get_schema(self, get_stats=False):\\n query = \\\"schema {}\\\"\\n\\n results = self.run_dgraph_query_raw(query)\\n\\n schema = {}\\n\\n for row in results[\\\"schema\\\"]:\\n table_name = row[\\\"predicate\\\"]\\n\\n if table_name not in schema:\\n schema[table_name] = {\\\"name\\\": table_name, \\\"columns\\\": []}\\n\\n return list(schema.values())\",\n \"def full_schema_list(self, schema: str) -> List[str]:\\n # Generate the information_schema identifier for that database\\n # in order to be able to filter it out\\n name_parts = schema.split(\\\".\\\")\\n\\n info_schema = f\\\"{name_parts[0]}.information_schema\\\"\\n\\n fetched_schemas = []\\n\\n # All Schemas\\n if name_parts[1] == \\\"*\\\":\\n db_schemas = self.show_schemas(name_parts[0])\\n for db_schema in db_schemas:\\n if db_schema != info_schema:\\n fetched_schemas.append(db_schema)\\n\\n # Prefix schema match\\n elif \\\"*\\\" in name_parts[1]:\\n db_schemas = self.show_schemas(name_parts[0])\\n for db_schema in db_schemas:\\n schema_name = db_schema.split(\\\".\\\", 1)[1].lower()\\n if schema_name.startswith(name_parts[1].split(\\\"*\\\", 1)[0]):\\n fetched_schemas.append(db_schema)\\n\\n # TODO Handle more complicated matches\\n\\n else:\\n # If no * in name, then return provided schema name\\n fetched_schemas = [schema]\\n\\n return fetched_schemas\",\n \"def load_dde_schemas(self, schema):\\n url = DDE_SCHEMA_BASE_URL + schema\\n if self.verbose:\\n print(f'Loading registered DDE schema from \\\"{url}\\\"')\\n return load_json_or_yaml(url)[\\\"source\\\"]\",\n \"def create_schema():\\n schema = Schema(idx=ID(stored=True),\\n data=STORED,\\n body=TEXT(analyzer=StemmingAnalyzer()),\\n )\\n print(\\\"schema creation successful\\\")\\n return schema\",\n \"def schema(self):\\n pass\",\n \"def schema(self) -> graphql.GraphQLSchema:\\n return self._schema\",\n \"def schema(self):\\n raise NotImplementedError\",\n \"def get_schema(path):\\n with open(path, 'r') as f:\\n return json.load(f)\",\n \"def schemas(self):\\n return model.Schemas(self)\",\n \"def schema_for_state(self) -> Dict[str, Any]:\\n return self.rsimulator.schema_for_state()\",\n \"def get_schemas(self):\\n query = mssqlqueries.get_schemas()\\n logger.info(u'Schemas query: %s', query)\\n for tabular_result in self.execute_query(query):\\n return [x[0] for x in tabular_result[0]]\",\n \"def get_schema(self, repo, table):\\n return self.user_con.get_schema(repo=repo, table=table)\",\n \"def _schema_type(self) -> Optional[type]:\\n return PanelSchema\",\n \"def schemas(self):\\n return self.get_schemas()\",\n \"def getSchema(self):\\n\\n schema = [\\n \\\"title\\\",\\n \\\"body\\\",\\n \\\"created_at\\\",\\n \\\"id\\\",\\n \\\"summary\\\",\\n \\\"abstract\\\",\\n \\\"keywords\\\",\\n ]\\n\\n return schema\",\n \"def schemas(self):\\n if not self._schemas:\\n self._schemas = get_schema(self.attributes.workspace.namespace, self.attributes.workspace.name)\\n return self._schemas\",\n \"def schema(self) -> Optional[TensorDatasetSchema]:\\n try:\\n features_schema = _infer_schema(self._features)\\n targets_schema = None\\n if self._targets is not None:\\n targets_schema = _infer_schema(self._targets)\\n return TensorDatasetSchema(features=features_schema, targets=targets_schema)\\n except Exception as e:\\n _logger.warning(\\\"Failed to infer schema for NumPy dataset. Exception: %s\\\", e)\\n return None\",\n \"def get_schema_cls() -> t.Any:\\n return None\",\n \"def _schema_type(self) -> Optional[type]:\\n return SeriesPanelMetaSchema\",\n \"def get_schema_url(self):\\n return self.NAME_TYPE_SCHEMAS.get(self.name_type, None)\",\n \"def _schema_type(self) -> Optional[type]:\\n return AdBreakSchema\",\n \"def schema_helper(self, name, _, schema=None, **kwargs):\\n if schema is None:\\n return None\\n\\n schema_instance = resolve_schema_instance(schema)\\n\\n schema_key = make_schema_key(schema_instance)\\n self.warn_if_schema_already_in_spec(schema_key)\\n self.openapi.refs[schema_key] = name\\n\\n json_schema = self.openapi.schema2jsonschema(schema_instance)\\n\\n return json_schema\",\n \"def schema(self):\\n schema_el = self.root.xpath(\\n '/wsdl:definitions/wsdl:types/xsd:schema', namespaces=NS_MAP,\\n )[0]\\n return element_as_tree(schema_el)\",\n \"def reference_schema(self) -> pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaArgs']:\\n return pulumi.get(self, \\\"reference_schema\\\")\",\n \"def _schema(self):\\n\\n self._check_compiled()\\n return self._compiled._schema\",\n \"def schema(self):\\n return self.table_info.schema\",\n \"def get_local_schema(self, descriptor):\\n return self._schemas[descriptor]['local']\",\n \"def schema(self):\",\n \"def serializeSchema(schema):\\n\\n # determine portal_type\\n try:\\n prefix, portal_type, schemaName = splitSchemaName(schema.__name__)\\n except ValueError:\\n # not a dexterity schema\\n return\\n\\n # find the FTI and model\\n fti = queryUtility(IDexterityFTI, name=portal_type)\\n if fti.model_source:\\n model = fti.lookupModel()\\n\\n # synchronize changes to the model\\n syncSchema(schema, model.schemata[schemaName], overwrite=True)\\n fti.model_source = serializeModel(model)\\n else:\\n raise TypeError(\\\"Changes to non-dynamic schemata not yet supported.\\\")\",\n \"def parse_schema_from_string(schema_str):\\n return schema.Parse(schema_str)\",\n \"def get_meta_schema(self):\\n return self._tc_meta_schema\",\n \"def _schema_type(self) -> Optional[type]:\\n return MovieSchema\",\n \"def readjamschema(schema):\\n raise NotImplementedError(msg)\",\n \"def discover_schema(node):\\n xmlns = node.get('__xmlns__', None)\\n\\n if xmlns:\\n node['Schema'] = 'Unknown'\\n if xmlns.startswith('smpte_stereo'):\\n node['Schema'] = 'SMPTE Stereoscopic'\\n elif xmlns.startswith('smpte'):\\n node['Schema'] = 'SMPTE'\\n elif xmlns.startswith('interop'):\\n node['Schema'] = 'Interop'\\n elif xmlns.startswith('atmos'):\\n node['Schema'] = 'Atmos'\",\n \"def _get_schema_from_object(self, data):\\n if \\\"items\\\" in data:\\n return self._get_schema_from_object(data[\\\"items\\\"])\\n\\n url_key = None\\n\\n if '$id' in data:\\n url_key = '$id'\\n\\n if 'id' in data:\\n url_key = 'id'\\n\\n if url_key:\\n url = data[url_key]\\n schema = Schema().build()\\n schema.domain_entity = self.get_domain_entity_from_url(url)\\n schema.high_level_entity = self.get_high_level_entity_from_url(url)\\n schema.module = self.get_module_from_url(url)\\n schema.url = url\\n return schema\\n\\n return None\",\n \"def getSchema(self, fp_id: int) -> Dict:\\n # Identify the format\\n formatquery = (\\n \\\"\\\"\\\"select file_format from file_pattern_detail where fp_id = {0}\\\"\\\"\\\".format(\\n fp_id\\n )\\n )\\n formattype = self.getDataAsDict(formatquery)[0]\\n if formattype[\\\"file_format\\\"] == \\\"DELIMITED\\\":\\n schemaQuery = \\\"\\\"\\\"\\n select col_name,\\n col_datatype,\\n col_ordinal,\\n primary_key_pos,\\n is_defining_col,\\n is_audit_col\\n from delimited_col_detail where fp_detail_id = {}\\n \\\"\\\"\\\".format(\\n fp_id\\n )\\n data = self.getDataAsDict(schemaQuery)\\n return data\",\n \"def schema_xml(self):\\n return self.properties.get('SchemaXml', None)\",\n \"def load_schema(schema_path):\\n with open(schema_path) as schema_file:\\n return Utils.parse(schema_file.read())\",\n \"def _schema_type(self) -> Optional[type]:\\n return SigningPolicySchema\",\n \"def _validate_against_schema(self, strand, data):\\n schema = self._get_schema(strand)\\n\\n try:\\n jsonschema_validate(instance=data, schema=schema)\\n logger.debug(\\\"Validated %s against schema\\\", strand)\\n\\n except ValidationError as e:\\n raise exceptions.invalid_contents_map[strand](str(e))\",\n \"def get_schemas(self, conn):\\n return conn.get_schemas()['table_schema']\",\n \"def _get_schema(self):\\n self.to_dask()\\n return Schema(dtype=self._df.dtypes,\\n shape=(None, len(self._df.columns)),\\n npartitions=self._df.npartitions,\\n metadata=self.metadata)\",\n \"def get_schema_structure(self) -> SchemaStructure:\\n constructors: List[CombinatorData] = list(\\n self._combinator_map.values()\\n )\\n methods: List[FunctionData] = list(\\n self._function_map.values()\\n )\\n\\n return SchemaStructure(constructors=constructors, methods=methods)\",\n \"def JSONSchema(self, default=None):\\n return self.data.get('metadata', {}).get('$schema', default)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66698045","0.6518725","0.6390867","0.6313399","0.6210594","0.62096435","0.61262435","0.61096203","0.6025287","0.5981262","0.5939648","0.5933518","0.5902661","0.58778864","0.5872866","0.58726424","0.58520615","0.58372164","0.58244634","0.5824207","0.581969","0.5783459","0.5776963","0.57689315","0.57574755","0.5726965","0.57250506","0.5714461","0.5697706","0.56923294","0.56688327","0.5665392","0.56356925","0.56322044","0.5609556","0.5597766","0.5548235","0.5541266","0.55236185","0.55118716","0.5503674","0.54893935","0.546701","0.5457018","0.5451556","0.54461867","0.5429848","0.53786594","0.53594714","0.53580964","0.5341359","0.5320134","0.5313377","0.53090924","0.53016293","0.52810794","0.5273553","0.52470654","0.5203085","0.5201358","0.51940435","0.5167343","0.51617956","0.5161381","0.51533","0.5152831","0.51415414","0.51373535","0.5134352","0.51117676","0.5091775","0.50913453","0.5090095","0.50797313","0.5066588","0.50664735","0.5064499","0.50513864","0.50385195","0.50379115","0.5031788","0.5031475","0.50293505","0.50254554","0.5022628","0.5012679","0.50097924","0.5006238","0.50053716","0.5003605","0.5000007","0.49880132","0.49860084","0.49856916","0.4972932","0.49688518","0.4964152","0.49598068","0.4958572","0.49577603"],"string":"[\n \"0.66698045\",\n \"0.6518725\",\n \"0.6390867\",\n \"0.6313399\",\n \"0.6210594\",\n \"0.62096435\",\n \"0.61262435\",\n \"0.61096203\",\n \"0.6025287\",\n \"0.5981262\",\n \"0.5939648\",\n \"0.5933518\",\n \"0.5902661\",\n \"0.58778864\",\n \"0.5872866\",\n \"0.58726424\",\n \"0.58520615\",\n \"0.58372164\",\n \"0.58244634\",\n \"0.5824207\",\n \"0.581969\",\n \"0.5783459\",\n \"0.5776963\",\n \"0.57689315\",\n \"0.57574755\",\n \"0.5726965\",\n \"0.57250506\",\n \"0.5714461\",\n \"0.5697706\",\n \"0.56923294\",\n \"0.56688327\",\n \"0.5665392\",\n \"0.56356925\",\n \"0.56322044\",\n \"0.5609556\",\n \"0.5597766\",\n \"0.5548235\",\n \"0.5541266\",\n \"0.55236185\",\n \"0.55118716\",\n \"0.5503674\",\n \"0.54893935\",\n \"0.546701\",\n \"0.5457018\",\n \"0.5451556\",\n \"0.54461867\",\n \"0.5429848\",\n \"0.53786594\",\n \"0.53594714\",\n \"0.53580964\",\n \"0.5341359\",\n \"0.5320134\",\n \"0.5313377\",\n \"0.53090924\",\n \"0.53016293\",\n \"0.52810794\",\n \"0.5273553\",\n \"0.52470654\",\n \"0.5203085\",\n \"0.5201358\",\n \"0.51940435\",\n \"0.5167343\",\n \"0.51617956\",\n \"0.5161381\",\n \"0.51533\",\n \"0.5152831\",\n \"0.51415414\",\n \"0.51373535\",\n \"0.5134352\",\n \"0.51117676\",\n \"0.5091775\",\n \"0.50913453\",\n \"0.5090095\",\n \"0.50797313\",\n \"0.5066588\",\n \"0.50664735\",\n \"0.5064499\",\n \"0.50513864\",\n \"0.50385195\",\n \"0.50379115\",\n \"0.5031788\",\n \"0.5031475\",\n \"0.50293505\",\n \"0.50254554\",\n \"0.5022628\",\n \"0.5012679\",\n \"0.50097924\",\n \"0.5006238\",\n \"0.50053716\",\n \"0.5003605\",\n \"0.5000007\",\n \"0.49880132\",\n \"0.49860084\",\n \"0.49856916\",\n \"0.4972932\",\n \"0.49688518\",\n \"0.4964152\",\n \"0.49598068\",\n \"0.4958572\",\n \"0.49577603\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8233626"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4493,"cells":{"query":{"kind":"string","value":"Validate data against a schema, raises exceptions of type InvalidJson if not compliant."},"document":{"kind":"string","value":"def _validate_against_schema(self, strand, data):\n schema = self._get_schema(strand)\n\n try:\n jsonschema_validate(instance=data, schema=schema)\n logger.debug(\"Validated %s against schema\", strand)\n\n except ValidationError as e:\n raise exceptions.invalid_contents_map[strand](str(e))"},"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 validate(self, json_data):\n self._errors = None\n success = True\n for item in self._schema:\n if not item.validate(json_data):\n success = False\n\n return success","def validate_schema(*,\n jsonschema: dict,\n data: Any\n ) -> None:\n # from typing import TYPE_CHECKING\n # if not TYPE_CHECKING:\n # otherwise mypy raises error\n # return\n\n _errors: defaultdict = defaultdict(list)\n\n def set_nested_item(data_dict, path, key, val): # type: ignore\n for _key in path:\n data_dict.setdefault(_key, {})\n data_dict = data_dict[_key]\n\n data_dict.setdefault(key, list())\n data_dict[key].append(val)\n\n for err in Draft7Validator(schema=jsonschema).iter_errors(instance=data):\n path = err.schema_path\n\n if \"properties\" in path:\n path.remove(\"properties\")\n key = path.popleft()\n\n if \"required\" in path or key == \"required\":\n key = err.message.split(\"'\")[1]\n elif err.relative_path:\n key = err.relative_path.pop()\n\n set_nested_item(_errors, err.relative_path, key, err.message)\n\n if _errors:\n raise app_exceptions.ValidateDataError(dict(_errors))","def validate_json_schema(self, json_schema):\n cls = validators.validator_for(json_schema)\n cls.check_schema(json_schema)","def test_validate_json_validates_schema(self):\n invalid_schema = {\"type\": \"any\"}\n valid_json = {}\n test_model = RecordSchema(schema=invalid_schema)\n\n with self.assertRaises(jsonschema.exceptions.SchemaError):\n test_model.validate_json(valid_json)","def test_validate_json(self):\n # Lifted directly from the python-jsonschema docs\n test_schema = {\"type\": \"object\",\n \"properties\": {\n \"price\": {\"type\": \"number\"},\n \"name\": {\"type\": \"string\"},\n }}\n valid = {\"name\": \"Eggs\", \"price\": 34.99}\n invalid = {\"name\": \"Eggs\", \"price\": \"Invalid\"}\n\n test_model = RecordSchema(schema=test_schema)\n\n self.assertIsNone(test_model.validate_json(valid))\n\n with self.assertRaises(jsonschema.exceptions.ValidationError):\n test_model.validate_json(invalid)","def check_valid_schema(context):\n data = context.response.json()\n validate_schema(data)","def validate_schema(self, schema):\n json_schema_path = os.path.join(_ROOT, 'data', 'schema.json')\n json_schema = load_json_or_yaml(json_schema_path)\n return validate(schema, json_schema)","def validate_data(schema_cls: Serializer, data: dict) -> dict:\n schema = schema_cls(data=data)\n schema.is_valid(raise_exception=True)\n return schema.validated_data","def validate_against_schema(request, schema, data):\n try:\n data_pure = schema.deserialize(data)\n data_clean = post_serialize(data_pure)\n # Attach data_clean to request: see usage in views.\n request.data_clean = data_clean\n except Invalid as e:\n # here we transform the errors we got from colander into cornice\n # errors\n for field, error in e.asdict().items():\n request.errors.add('body', field, error)","def validate(self, json_data):\n try:\n self.process_json(json_data)\n except ValueError as e:\n # self.process_errors.append(e.args[0])\n self.process_errors = [e.args[0]]\n\n self.errors = list(self.process_errors)\n\n # Run validators\n if not self.errors:\n chain = itertools.chain(self.validators)\n self._run_validation_chain(chain)\n\n return len(self.errors) == 0","def validator(data_json):\n fields = spec[\"fields\"]\n data = json.loads(data_json, object_pairs_hook=collections.OrderedDict)\n for k, v in fields.items():\n if v.get(\"required\"):\n found = False\n if k in data:\n found = True\n elif \".\" in k:\n # Dotted keys could be nested, like ecs.version\n subkeys = k.split(\".\")\n subval = data\n for subkey in subkeys:\n subval = subval.get(subkey, {})\n if subval:\n found = True\n if not found:\n raise ValidationError(\"Missing required key {}\".format(k))\n if k in data:\n if v[\"type\"] == \"string\" and not (\n isinstance(data[k], str) or isinstance(data[k], basestring)\n ):\n raise ValidationError(\n \"Value {0} for key {1} should be string, is {2}\".format(\n data[k], k, type(data[k])\n )\n )\n if v[\"type\"] == \"datetime\":\n try:\n datetime.datetime.strptime(data[k], \"%Y-%m-%dT%H:%M:%S.%fZ\")\n except ValueError:\n raise ValidationError(\n \"Value {0} for key {1} doesn't parse as an ISO datetime\".format(\n data[k], k\n )\n )\n if v.get(\"index\") and list(data.keys())[v.get(\"index\")] != k:\n raise ValidationError(\"Key {0} is not at index {1}\".format(k, index))\n\n return data_json","def validate_against_schema(self, json_doc):\n if self.uri not in self.se.validation:\n raise RuntimeError(\"$validation is not defined for {} field; thus the json document could not be validated\".format(self.name))\n else:\n validate(json_doc, self.se.validation[self.uri])\n print('The JSON document is valid')","def validate_json(self):\n pass","def validate(cls, data, schema=None):\n if data is None:\n raise APIError(\n \"Data of the apartment to be created must be passed a json body\",\n status=400,\n )\n\n try:\n if schema is None:\n return data\n\n return schema.load(data)\n except ValidationError as error:\n raise APIError(\n \"Error validating input data\", causes=error.messages\n ) from error","def validate_json(self, data, schema):\n validator = jsonschema.Draft7Validator(schema, format_checker=jsonschema.draft7_format_checker)\n errors = validator.iter_errors(data)\n error_list = [(error.message, str(error.path), error) for error in errors]\n return error_list","def is_json_valid(json_data: dict, json_schema: dict) -> bool:\r\n try:\r\n validate(instance=json_data, schema=json_schema)\r\n except jsonschema.exceptions.ValidationError as err:\r\n return False\r\n return True","def assert_valid_schema(data, schema_file):\n\n schema = _load_json_schema(schema_file)\n return validate(data, schema)","def _validate(self):\n schema_version = util.schemas[self.schema_name]\n stored_schemas = util.stored_schemas\n\n try:\n schema_obj = stored_schemas[\n \"http://redfish.dmtf.org/schemas/v1/\" + schema_version]\n except KeyError:\n raise OneViewRedfishError(\"{} not found\".format(schema_version))\n\n resolver = jsonschema.RefResolver('', schema_obj, store=stored_schemas)\n jsonschema.validate(self.redfish, schema_obj, resolver=resolver)","def validate_json_schema(path, name, data, schema, full_schema=not is_extension):\n errors = 0\n\n # The standard repository has an example extension.\n if 'docs/examples/organizations/organizational_units/ocds_divisionCode_extension' in path:\n full_schema = False\n\n # Kingfisher Collect uses JSON Schema files to validate Scrapy items.\n code_repo = repo_name == 'kingfisher-collect'\n\n # Non-OCDS schema don't:\n # * pair \"enum\" and \"codelist\"\n # * disallow \"null\" in \"type\" of \"items\"\n # * UpperCamelCase definitions and lowerCamelCase properties\n # * allow \"null\" in the \"type\" of optional fields\n # * include \"id\" fields in objects within arrays\n # * require \"title\", \"description\" and \"type\" properties\n json_schema_exceptions = {\n 'json-schema-draft-4.json',\n 'meta-schema.json',\n 'meta-schema-patch.json',\n }\n ocds_schema_exceptions = {\n 'dereferenced-release-schema.json',\n # standard-maintenance-scripts\n 'codelist-schema.json',\n 'extension-schema.json',\n # extension_registry\n 'extensions-schema.json',\n 'extension_versions-schema.json',\n # spoonbill\n 'ocds-simplified-schema.json',\n }\n schema_exceptions = json_schema_exceptions | ocds_schema_exceptions\n\n validate_items_type_kwargs = {\n 'allow_invalid': {\n '/definitions/Amendment/properties/changes/items', # deprecated\n '/definitions/AmendmentUnversioned/properties/changes/items', # deprecated\n '/definitions/record/properties/releases/oneOf/0/items', # 1.1\n },\n }\n\n def validate_codelist_enum_allow_missing(codelist):\n return is_extension and codelist in external_codelists\n\n validate_codelist_enum_kwargs = {\n 'fallback': {\n '/definitions/Metric/properties/id': ['string'],\n '/definitions/Milestone/properties/code': ['string', 'null'],\n },\n 'allow_missing': validate_codelist_enum_allow_missing,\n }\n\n validate_letter_case_kwargs = {\n 'property_exceptions': {'former_value'}, # deprecated\n 'definition_exceptions': {'record'}, # 1.1\n }\n\n def validate_metadata_presence_allow_missing(pointer):\n return 'links' in pointer.split('/') or code_repo # ocds_pagination_extension\n\n validate_metadata_presence_kwargs = {\n 'allow_missing': validate_metadata_presence_allow_missing,\n }\n\n def validate_object_id_allow_missing(pointer):\n parts = pointer.split('/')\n return 'versionedRelease' in parts or parts[-1] in {\n 'changes', # deprecated\n 'records', # uses `ocid` not `id`\n '0', # linked releases\n }\n\n validate_object_id_kwargs = {\n 'allow_missing': validate_object_id_allow_missing,\n 'allow_optional': {\n # 2.0 fixes.\n # See https://github.com/open-contracting/standard/issues/650\n '/definitions/Amendment',\n '/definitions/Organization',\n '/definitions/OrganizationReference',\n '/definitions/RelatedProcess',\n },\n }\n if repo_name == 'infrastructure':\n validate_object_id_kwargs['allow_optional'].add('/definitions/Classification')\n\n validate_null_type_kwargs = {\n # OCDS allows null. OC4IDS disallows null.\n 'no_null': repo_name == 'infrastructure' or code_repo,\n 'allow_object_null': {\n '/definitions/Amendment/properties/changes/items/properties/former_value', # deprecated\n # See https://github.com/open-contracting/standard/pull/738#issuecomment-440727233\n '/definitions/Organization/properties/details',\n },\n 'allow_no_null': {\n '/definitions/Amendment/properties/changes/items/properties/property', # deprecated\n\n # Children of fields with omitWhenMerged.\n '/definitions/Link/properties/rel',\n '/definitions/Link/properties/href',\n\n # 2.0 fixes.\n # See https://github.com/open-contracting/standard/issues/650\n '/definitions/Organization/properties/id',\n '/definitions/OrganizationReference/properties/id',\n '/definitions/RelatedProcess/properties/id',\n },\n }\n\n validate_array_items_kwargs = {\n 'allow_invalid': {\n '/definitions/Amendment/properties/changes/items/properties/former_value', # deprecated\n '/definitions/Location/properties/geometry/properties/coordinates/items', # recursion\n },\n }\n\n validate_deep_properties_kwargs = {\n 'allow_deep': {\n '/definitions/Amendment/properties/changes/items', # deprecated\n },\n }\n if is_extension: # avoid repetition in extensions\n validate_deep_properties_kwargs['allow_deep'].add('/definitions/Item/properties/unit')\n\n validator = Draft4Validator(schema, format_checker=FormatChecker())\n\n errors += validate_schema(path, data, validator)\n if errors:\n warnings.warn(f'{path} is not valid JSON Schema ({errors} errors)')\n\n if name not in schema_exceptions:\n if 'versioned-release-validation-schema.json' in path:\n validate_items_type_kwargs['additional_valid_types'] = ['object']\n errors += validate_array_items(path, data, **validate_array_items_kwargs)\n errors += validate_items_type(path, data, **validate_items_type_kwargs)\n if not code_repo:\n errors += validate_codelist_enum(path, data, **validate_codelist_enum_kwargs)\n errors += validate_letter_case(path, data, **validate_letter_case_kwargs)\n errors += validate_merge_properties(path, data)\n\n # `full_schema` is set to not expect extensions to repeat information from core.\n if full_schema:\n exceptions_plus_versioned = schema_exceptions | {\n 'versioned-release-validation-schema.json',\n }\n\n exceptions_plus_versioned_and_packages = exceptions_plus_versioned | {\n 'project-package-schema.json',\n 'record-package-schema.json',\n 'release-package-schema.json',\n }\n\n if not code_repo:\n # Extensions aren't expected to repeat referenced `definitions`.\n errors += validate_ref(path, data)\n\n if name not in exceptions_plus_versioned:\n # Extensions aren't expected to repeat `title`, `description`, `type`.\n errors += validate_metadata_presence(path, data, **validate_metadata_presence_kwargs)\n if not code_repo:\n # Extensions aren't expected to repeat referenced `definitions`.\n errors += validate_object_id(path, jsonref.replace_refs(data), **validate_object_id_kwargs)\n\n if name not in exceptions_plus_versioned_and_packages:\n # Extensions aren't expected to repeat `required`. Packages don't have merge rules.\n errors += validate_null_type(path, data, **validate_null_type_kwargs)\n # Extensions aren't expected to repeat referenced codelist CSV files\n # TODO: This code assumes each schema uses all codelists. So, for now, skip package schema.\n errors += validate_schema_codelists_match(path, data, cwd, is_extension, is_profile, external_codelists)\n\n else:\n # Don't count these as errors.\n validate_deep_properties(path, data, **validate_deep_properties_kwargs)\n\n assert not errors, 'One or more JSON Schema files are invalid. See warnings below.'","def validate(schema):\n def decorator(func):\n def wrapper(self, req, resp, *args, **kwargs):\n try:\n raw_json = req.stream.read()\n obj = json.loads(raw_json.decode('utf-8'))\n obj['req_id'] = req.context.get('request_id')\n except Exception:\n raise falcon.HTTPBadRequest(\n title='Invalid data',\n description='Could not properly parse the provided data as JSON',\n code='001'\n )\n\n try:\n jsonschema.validate(obj, schema)\n except jsonschema.ValidationError as e:\n raise falcon.HTTPBadRequest(\n title='Failed data validation',\n description=e.message,\n code='002'\n )\n\n return func(self, req, resp, *args, parsed=obj, **kwargs)\n return wrapper\n return decorator","def validateJSON(jsonData):\n try:\n json.loads(jsonData)\n validate(instance=json.loads(jsonData), schema=read_json_schema(schema_file_path))\n except Exception as err:\n logging.error(err)\n logging.info(\" Message received is not correct \")\n logging.info(\" Message sent to Pulsar Rejection Topic for reprocessing\")\n # IF a message is not correct, I prefer to stop the consumer and fix the problem. Another way will be to\n # Send message to another to topic if the message is not valid and change raise below by pass.\n raise\n return False\n\n return True","def validator(request, schema):\n try:\n body = request.body.decode('utf-8')\n dictbody = json.loads(body) if body else {}\n validate_against_schema(request, schema, dictbody)\n except ValueError as e:\n request.errors.add('body', 'body', six.text_type(e))","def validate_json(schema, doc):\n is_invalid = set(doc).difference(set(schema))\n if is_invalid:\n return False\n return True","def validate(obj, schema=PROCESSING_SERVER_CONFIG_SCHEMA):\n return JsonValidator.validate(obj, schema)","def validate(self) -> None:\n schema = type(self).schema\n if schema:\n if self.data is None:\n raise PresenterException(\"No data given.\")\n try:\n schema(self.data)\n except JsonSchemaException as exception:\n raise PresenterException(exception.message)\n else:\n if self.data is not None:\n raise PresenterException(\"This presenter does not take data.\")","def assert_valid_schema(data, schemafile):\n\n schema = _load_json_schema(schemafile)\n return validate(data, schema)","def validate(cls, data, errors):","def decide_schema(self, json_data):\n pass","def decide_schema(self, json_data):\n pass","def validate(data):\n try:\n return Schema(Validator.SCHEMA).validate(data)\n except SchemaError as exception:\n logging.getLogger(__name__).error(exception)\n return None","def test_validate_schema():\n data = {\n 'business': {\n 'cacheId': 1,\n 'foundingDate': '2007-04-08T00:00:00+00:00',\n 'identifier': 'CP1234567',\n 'legalName': 'legal name CP1234567'\n },\n }\n\n is_valid, _ = validate(data, 'business', validate_schema=True)\n\n assert is_valid","def validate(self, data):\n age = data.get(\"age\", None)\n age = age.split(\",\")\n size = data.get(\"size\", None)\n size = size.split(\",\")\n gender = data.get(\"gender\", None)\n gender = gender.split(\",\")\n for i in age:\n if i not in ['b', 'y', 'a', 's']:\n raise serializers.ValidationError(\n \"Age must be either 'b' for baby, 'y' for young,\"\n \" 'a' for adult, or 's' for senior. Can do multiple with\"\n \" commas, ex: a,y,e\")\n for i in size:\n if i not in ['s', 'm', 'l', 'xl']:\n raise serializers.ValidationError(\n \"Size must be either 's' for small, 'm' for medium, 'l' \"\n \"for large, or 'xl' for extra large. Can do multiple with\"\n \" commas, ex: s,l,xl\")\n for i in gender:\n if i not in ['m', 'f']:\n raise serializers.ValidationError(\n \"Gender must be either 'm' for male, or 'f' for female. Can\"\n \" have both using commas, ex: m,f\")\n return data","def validate(json_resp, schema, validictory_path, schema_base=None):\n # assumes /extern/validictory exists (see /cm for instructions)\n if not validictory_path in sys.path:\n sys.path.append(validictory_path)\n import validictory\n\n try:\n if schema_base and not json_resp[\"$schema\"].startswith(schema_base):\n print \"Warning: JSON schema is \", json_resp[\"$schema\"], \"instead of \", schema_base\n validictory.validate(json_resp, schema, required_by_default=False)\n return True\n except Exception as e:\n print \"Received exception %s while trying to validate: %s\" % (\n str(e), json_resp)\n return False","def validate_schema(schema):\n def decorator(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n\n try:\n validate(request.json, schema)\n except:\n return bad_request()\n\n return func(*args, **kwargs)\n\n return wrapper\n\n return decorator","def test_invalid_schema():\n # setup\n uid = uuid.uuid4()\n schema_dir = f'/tmp/{uid}'\n schema_file = f'{schema_dir}/bad_schema.json'\n os.makedirs(schema_dir)\n text_file = open(schema_file, 'w')\n text_file.write('this will fail[];fail()')\n text_file.close()\n\n data = {}\n\n # test\n is_valid, errors = validate(data, 'bad_schema', validate_schema=True)\n\n # teardown\n os.remove(schema_file)\n os.removedirs(schema_dir)\n\n assert not is_valid\n assert errors","def validate(data, schema, resolver):\n try:\n # if valid returns None\n return Draft7Validator(schema=schema, resolver=resolver).validate(data)\n except ValidationError:\n raise ValidationError(\"data couldn't be validated.\")\n except RefResolutionError:\n raise RefResolutionError(\"schema references couldn't be solved.\")","def validate_insert_json(request_json):\n try:\n jsonschema.validate(request_json, schema_input)\n except (jsonschema.exceptions.ValidationError, jsonschema.exceptions.SchemaError, JSONDecodeError) as e:\n current_app.logger.info(\"Invalid json:{}\".format(str(e)))\n raise (InvalidJSONError(\"Invalid json:{}\".format(str(e))))","def validate_property_schema(self, schema):\n json_schema_path = os.path.join(_ROOT,\n 'data',\n 'property_json_schema.json')\n json_schema = load_json_or_yaml(json_schema_path)\n return validate(schema, json_schema)","def validate(json_data: json,\n schema_id: str,\n schema_store: dict = None,\n validate_schema: bool = False,\n schema_search_path: str = None\n ) -> Tuple[bool, iter]:\n try:\n if not schema_search_path:\n schema_search_path = path.join(path.dirname(__file__), 'schemas')\n\n if not schema_store:\n schema_store = get_schema_store(validate_schema, schema_search_path)\n\n schema = schema_store.get(f'{BASE_URI}/{schema_id}')\n if validate_schema:\n Draft7Validator.check_schema(schema)\n\n schema_file_path = path.join(schema_search_path, schema_id)\n resolver = RefResolver(f'file://{schema_file_path}.json', schema, schema_store)\n\n if Draft7Validator(schema,\n format_checker=Draft7Validator.FORMAT_CHECKER,\n resolver=resolver\n ) \\\n .is_valid(json_data):\n return True, None\n\n errors = Draft7Validator(schema,\n format_checker=Draft7Validator.FORMAT_CHECKER,\n resolver=resolver\n ) \\\n .iter_errors(json_data)\n return False, errors\n\n except SchemaError as error:\n # handle schema error\n return False, error","def validate(document, schema=\"ctsa::bts:CTSADataset\"):\n try:\n document = ensure_document(document)\n schema = ensure_schema(schema)\n\n except (TypeError, ValueError) as err:\n raise DatasetValidationError(err)\n\n try:\n validator = jsonschema.Draft7Validator(schema)\n if not validator.is_valid(document):\n errors = []\n for error in sorted(validator.iter_errors(document), key=str):\n errors.append(error.message)\n raise DatasetJsonSchemaValidationError(errors)\n except jsonschema.exceptions.SchemaError as err: #Invalid Schema\n raise DatasetJsonSchemaValidationError(err)\n except jsonschema.exceptions.ValidationError as err: #Invalid Doc\n raise DatasetJsonSchemaValidationError(err)\n except Exception as exc: # unexpected errors\n raise DatasetValidationError(str(exc))\n\n return ValidatedDict(document)","def validate_api_resp(actual_json_resp, json_schema_path: str, json_schema_file_name):\n with open(os.path.join(JSON_SCHEMA_ROOT, json_schema_path, json_schema_file_name), 'r') as f:\n json_schema = json.loads(f.read())\n actual_json = json.loads(str(actual_json_resp.data, 'utf-8'))\n jsonschema.validate(actual_json, json_schema)","def schema_validation(schema):\n def decorator(function):\n @wraps(function)\n def wrapper(*args, **kwargs):\n data = {}\n if request.method in ['POST', 'PATCH', 'PUT']:\n data = request.get_json(force=True)\n elif request.method in ['GET', 'DELETE']:\n data = request.args.to_dict()\n\n v = Validator(schema)\n v.allow_unknown = True\n if v.validate(data):\n return function(*args, **kwargs)\n else:\n return jsonify({'errors': v.errors}), 400\n\n return wrapper\n return decorator","def validate_data(self, data):\n # TODO use schema\n assert \"file_contents\" in data, data\n assert \"type\" in data, data","def isValidForSchema(schema):\n\n return True","def validate_with(schema):\n def decorator(f):\n @functools.wraps(f)\n def wrapper(*args, **kwargs):\n if not (request.json or request.data or request.form):\n flask_restful.abort(400, message='Validation error.',\n errors=['No data provided.'])\n try:\n data = schema(prepare_request_data(request))\n except voluptuous.MultipleInvalid as err:\n flask_restful.abort(400,\n message='Validation error.',\n errors=[str(e) for e in err.errors])\n setattr(request, 'validated_body', data)\n return f(*args, **kwargs)\n return wrapper\n return decorator","def validate_json(data: dict) -> bool:\n try:\n assert \"data\" in data.keys()\n assert isinstance(data[\"data\"], str)\n assert \"command\" in data.keys()\n assert isinstance(data[\"command\"], str)\n assert \"time\" in data.keys()\n assert isinstance(data[\"time\"], str)\n assert \"origin\" in data.keys()\n assert isinstance(data[\"origin\"], str)\n return True\n except AssertionError:\n return False","def validate_payload(cls, event):\n # TODO: Use invenio-jsonschemas/jsonresolver instead of this\n # Validate against Event JSONSchema\n # NOTE: raises `jsonschemas.ValidationError`\n cls._jsonschema_validator.validate(event)\n\n # Validate using marshmallow loader\n for payload in event:\n errors = RelationshipSchema(check_existing=True).validate(payload)\n if errors:\n raise MarshmallowValidationError(str(errors) + \"payload\" + str(payload))","def assertValidJSON(self, data):\r\n # Just try the load. If it throws an exception, the test case will fail.\r\n self.serializer.from_json(data)","def test_schema_invalid_json(self):\n schema_0_input = schema_nested_2_invalid_JSON\n\n # if you uncomment this line:\n # schema_0_input = schema_nested_2\n # this will fail the test: Failed: DID NOT RAISE <class 'simplejson.scanner.JSONDecodeError'>\n # because this is a valid schema\n\n with pytest.raises(simplejson.scanner.JSONDecodeError):\n msg = singer.parse_message(schema_0_input)","def validate_class_schema(self, schema):\n json_schema_path = os.path.join(_ROOT,\n 'data',\n 'class_json_schema.json')\n json_schema = load_json_or_yaml(json_schema_path)\n return validate(schema, json_schema)","def validator(data):\n\n request_validator = cerberus.Validator(SCHEMA)\n if request_validator.validate(data):\n return True\n else:\n return request_validator.errors","def validate(self, schema=None, callback=None):\n return hxl.schema(schema, callback).validate(self)","def validate(self, config_json):\n pass","def testCheck(self):\r\n from pydsl.Grammar.Definition import JsonSchema\r\n from pydsl.Check import JsonSchemaChecker\r\n schema = {\r\n \"type\" : \"string\",\r\n \"items\" : {\r\n \"type\" : [\"string\", \"object\"],\r\n \"properties\" : {\r\n \"foo\" : {\"enum\" : [1, 3]},\r\n #\"bar\" : { #See https://github.com/Julian/jsonschema/issues/89\r\n # \"type\" : \"array\",\r\n # \"properties\" : {\r\n # \"bar\" : {\"required\" : True},\r\n # \"baz\" : {\"minItems\" : 2},\r\n # }\r\n #}\r\n }\r\n }\r\n }\r\n grammardef = JsonSchema(schema)\r\n checker = JsonSchemaChecker(grammardef)\r\n self.assertTrue(checker.check(\"a\"))\r\n self.assertFalse(checker.check([1, {\"foo\" : 2, \"bar\" : {\"baz\" : [1]}}, \"quux\"]))","def validate(validator, document):\n try:\n validator.validate(document)\n except jsonschema.ValidationError as ex:\n raise wsgi_errors.HTTPBadRequestBody(\n '{0}: {1}'.format(ex.args, ex.message)\n )","def validate(self) -> bool:\n\n # Start by reading in the blueprint schema json\n schema = json.loads(pkgutil.get_data(\"FactorioTools\", \"blueprintSchema.json\"))\n\n # Validate the object's schema against the blueprintSchema JSON\n try:\n jsonschema.validate(self.data, schema)\n return True\n except jsonschema.ValidationError:\n pass\n\n return False","def check_schema(body, schema):\n validator = jsonschema.Draft4Validator(\n schema, format_checker=jsonschema.FormatChecker())\n try:\n validator.validate(body)\n except jsonschema.ValidationError as exc:\n raise exception.InvalidParameterValue(_('Invalid create body: %s') %\n exc)","def validate(\n instance: typing.Union[typing.Dict[str, typing.Any], typing.List[typing.Any]],\n schema: typing.Dict[str, typing.Any],\n path: typing.Optional[typing.List[str]] = None,\n allow_disabled_languages: bool = False,\n strict: bool = False\n) -> None:\n if path is None:\n path = []\n if not isinstance(schema, dict):\n raise ValidationError('invalid schema (must be dict)', path)\n if 'type' not in schema:\n raise ValidationError('invalid schema (must contain type)', path)\n if schema['type'] == 'array' and isinstance(instance, list):\n return _validate_array(instance, schema, path, allow_disabled_languages=allow_disabled_languages, strict=strict)\n elif schema['type'] == 'object' and isinstance(instance, dict):\n return _validate_object(instance, schema, path, allow_disabled_languages=allow_disabled_languages, strict=strict)\n elif schema['type'] == 'text' and isinstance(instance, dict):\n return _validate_text(instance, schema, path, allow_disabled_languages=allow_disabled_languages)\n elif schema['type'] == 'datetime' and isinstance(instance, dict):\n return _validate_datetime(instance, schema, path)\n elif schema['type'] == 'bool' and isinstance(instance, dict):\n return _validate_bool(instance, schema, path)\n elif schema['type'] == 'quantity' and isinstance(instance, dict):\n return _validate_quantity(instance, schema, path)\n elif schema['type'] == 'sample' and isinstance(instance, dict):\n return _validate_sample(instance, schema, path)\n elif schema['type'] == 'measurement' and isinstance(instance, dict):\n return _validate_measurement(instance, schema, path)\n elif schema['type'] == 'object_reference' and isinstance(instance, dict):\n return _validate_object_reference(instance, schema, path)\n elif schema['type'] == 'tags' and isinstance(instance, dict):\n return _validate_tags(instance, schema, path, strict=strict)\n elif schema['type'] == 'hazards' and isinstance(instance, dict):\n return _validate_hazards(instance, schema, path)\n elif schema['type'] == 'user' and isinstance(instance, dict):\n return _validate_user(instance, schema, path)\n elif schema['type'] == 'plotly_chart' and isinstance(instance, dict):\n return _validate_plotly_chart(instance, schema, path)\n else:\n raise ValidationError('invalid type', path)","def validate(self, data):\n raise NotImplementedError(\"Inherit this class and override this method.\")","def validate(self, data):\n gender = data.get(\"gender\", None)\n size = data.get(\"size\", None)\n if gender not in ['m', 'f', 'u']:\n raise serializers.ValidationError(\n \"Gender must be either 'm' for male, 'f' \"\n \"for female, or 'u' for unknown.\")\n elif size not in ['s', 'm', 'l', 'xl', 'u']:\n raise serializers.ValidationError(\n \"Size must be 's' for small, 'm' for medium, 'l' for large,\"\n \" 'xl' for extra large, or 'u' for unknown.\")\n return data","def validate(schema, record):\n if six.PY3:\n return Utils._py3_validate(schema, record)\n else:\n return Utils._py2_validate(schema, record)","def validate_datasets(row):\n data_validator = DataJSONDataset(row)\n valid = data_validator.validate(validator_schema=row['validator_schema'])\n errors = data_validator.errors\n row['validation_errors'] = errors\n if not valid:\n logger.error(f'Error validating {row}: {errors}')","def validate_schema(payload, schema):\n errors = []\n validator = jsonschema.Draft4Validator(schema,\n format_checker=jsonschema.FormatChecker())\n for error in sorted(validator.iter_errors(payload), key=str):\n errors.append(error.message)\n\n return errors","def test_jsonschema_validation_with_schema_object(self):\n check_value = {\"a\": 1}\n schema = {\n \"type\": \"object\",\n \"properties\": {\n \"a\": {\n \"type\": \"integer\",\n \"const\": 1\n }\n }\n }\n jsonschema_validation(check_value, schema)","def validate_schema(self, data, **kwargs):\n if \"role\" not in data and \"visible\" not in data:\n raise ValidationError(_(\"Missing fields 'role' and/or 'visible'.\"))","def handle_marshmallow_validaton(err): # except ValidationError as err\n return jsonify(err.messages), 400 # bad request","def _verify_schema(schema):\n assert type(schema) in [dict, tuple], f'Expected a dict or a tuple but got {type(schema)}'\n if isinstance(schema, tuple):\n assert len(schema) == 2, f'Expected a tuple with length 2 but got length {len(schema)}'\n if schema[1] is not None:\n assert isinstance(schema[1], schema[0]), f'{str(schema[1])} does not have expected type {str(schema)}'\n elif isinstance(schema, dict):\n for sub_schema in schema.values():\n _verify_schema(sub_schema)","def validate(self, value):\n if isinstance(value, dict):\n if set(value.keys()) == {\"type\", \"coordinates\"}:\n if value[\"type\"] != self._type:\n self.error(f'{self._name} type must be \"{self._type}\"')\n return self.validate(value[\"coordinates\"])\n else:\n self.error(\n \"%s can only accept a valid GeoJson dictionary\"\n \" or lists of (x, y)\" % self._name\n )\n return\n elif not isinstance(value, (list, tuple)):\n self.error(\"%s can only accept lists of [x, y]\" % self._name)\n return\n\n validate = getattr(self, \"_validate_%s\" % self._type.lower())\n error = validate(value)\n if error:\n self.error(error)","def valid(schema=None):\n def dec(fun):\n @wraps(fun)\n def d_func(self, ctx, data, *a, **kw):\n try:\n validate(data['params'], schema)\n except ValidationError as err:\n raise InvalidParams(err)\n except SchemaError as err:\n raise InternalError(err)\n return fun(self, ctx, data['params'], *a, **kw)\n return d_func\n return dec","def validate(data):\n if 'value' not in data or \\\n 'category' not in data or \\\n 'classification' not in data or \\\n 'account' not in data:\n raise Exception('Missing required field.')\n classifications = ['Personal', 'Essential', 'Savings', 'Income']\n if data['classification'] not in classifications:\n raise Exception('Invalid classification.')","def validate(self, descriptor, schema_id):\n try:\n jsonschema.validate(descriptor, self.load_schema(schema_id))\n return True\n\n except ValidationError as e:\n log.error(\"Failed to validate Descriptor against schema '{}'\"\n .format(schema_id))\n self.error_msg = e.message\n log.error(e.message)\n return\n\n except SchemaError as e:\n log.error(\"Invalid Schema '{}'\".format(schema_id))\n self.error_msg = e.message\n log.debug(e)\n return","def validate(mapping: Mapping[str, Any], ref: str) -> List[SchemaError]:\n # pylint: disable=too-many-branches\n\n valid_err = None # type: Optional[jsonschema.ValidationError]\n try:\n jsonschema.validate(instance=mapping, schema=mapry.schemas.GRAPH)\n except jsonschema.ValidationError as err:\n valid_err = err\n\n if valid_err is not None:\n return [\n SchemaError(\n message=\"Does not follow json schema: {}\".format(\n valid_err.message),\n ref='/'.join([ref] + [str(part) for part in valid_err.path]))\n ]\n\n errors = [] # type: List[SchemaError]\n\n # Enforce name and description to be at the top of the schema\n if isinstance(mapping, collections.OrderedDict):\n mapping_keys = list(mapping.keys())\n\n if mapping_keys[0] != 'name':\n errors.append(\n SchemaError(\n message=(\n \"Expected name to be the first property of the schema, \"\n \"but got {}\").format(mapping_keys[0]),\n ref='{}/name'.format(ref)))\n\n if mapping_keys[1] != 'description':\n errors.append(\n SchemaError(\n message=(\n \"Expected description to be the second property \"\n \"of the schema, but got {}\").format(mapping_keys[1]),\n ref='{}/description'.format(ref)))\n\n # Register classes and embeds and\n # check that there are no duplicate class or embed names.\n name_set, name_errs = _validate_names(mapping=mapping, ref=ref)\n errors.extend(name_errs)\n\n # Validate class fields except properties\n if 'classes' in mapping:\n for i, cls_mapping in enumerate(mapping['classes']):\n errors.extend(\n _validate_class(\n mapping=cls_mapping, ref='{}/classes/{}'.format(ref, i)))\n\n # Validate properties of the classes and embeds\n types = _NONCOMPOSITE_TYPE_SET.copy()\n types.update(name_set)\n\n # Check that the graph properties are valid\n errors.extend(_validate_properties(mapping=mapping, ref=ref, types=types))\n\n # Check that the properties of the classes are valid\n if 'classes' in mapping:\n for i, cls_mapping in enumerate(mapping['classes']):\n errors.extend(\n _validate_properties(\n mapping=cls_mapping,\n ref='{}/classes/{}'.format(ref, i),\n types=types))\n\n # Check that the properties of the embeds are valid\n if 'embeds' in mapping:\n for i, embed_mapping in enumerate(mapping['embeds']):\n errors.extend(\n _validate_properties(\n mapping=embed_mapping,\n ref='{}/embeds/{}'.format(ref, i),\n types=types))\n\n # Check that all the plurals of the classes\n # do not conflict any of the graph properties\n errors.extend(_validate_plurals(mapping=mapping, ref=ref))\n\n return errors","def validate_full_schema(self):\n #self.check_duplicate_labels()\n for record in self.extension_schema['schema']['@graph']:\n #self.check_whether_atid_and_label_match(record)\n if record['@type'] == \"rdfs:Class\":\n self.validate_class_schema(record)\n #self.validate_class_label(record[\"@id\"])\n self.validate_validation_field(record)\n elif record['@type'] == \"rdf:Property\":\n self.validate_property_schema(record)\n #self.validate_property_label(record[\"@id\"])\n #self.validate_domainIncludes_field(record[\"http://schema.org/domainIncludes\"])\n #self.validate_rangeIncludes_field(record[\"http://schema.org/rangeIncludes\"])\n #else:\n # raise ValueError('wrong @type value found: {}'.format(record))","def _handle_with_schema_validation(success_handler, schema_dict):\n try:\n schema = Schema(schema_dict)\n args = schema(request.args.to_dict())\n except MultipleInvalid as e:\n return abort(400, 'value at %s failed validation: %s' % (e.path, e.msg))\n result = success_handler(args)\n return jsonify(result)","def is_schema_valid(self, schema):\n for k, v in schema.items():\n if v[0] == \"var_len\":\n assert len(v) == 2\n assert v[1] in TF_VALUE\n\n if v[0] == \"fixed_len\":\n assert len(v) == 3\n assert v[1] in TF_VALUE\n assert isinstance(v[2], list)","def get_valid_json_or_abort(schema):\n\n json_request = flask.request.get_json(force=True)\n\n try:\n jsonschema.validate(json_request, schema)\n except jsonschema.ValidationError as e:\n flask_restful.abort(400, message=e.message)\n else:\n return json_request","def test_schema_completeness_validation_valid_input(self):\n for complete_schema in list_of_schema_inputs:\n validate_json_schema_completeness(complete_schema)\n\n assert True","def json_attribs_check(func):\n @wraps(func)\n def inner_func(jsonStr):\n gslvtsSchema = {\"type\":\"object\",\n \"properties\":{\n \"tagID\": {\"type\":\"number\"}, \n \"UTC\": {\"type\":\"string\",\n \"format\":\"date-time\"}\n\t\t\t},\n\t\t\t\"required\":[\"tagID\",\"UTC\"]\n }\n try:\n jsonGslvts=json.loads(jsonStr)\n for elem in jsonGslvts:\n try: \n validate(elem, gslvtsSchema, format_checker=FormatChecker())\n except ValidationError, e:\n print \"[-] Invalid json post data. Check it, brah.\"\n print e\n raise AttributeError \n except (AttributeError, ValueError):\n print \"[-] IDk what that was, but it wasn't JSON.\"\n raise AttributeError\n\n return(func(jsonStr)) \n return inner_func","def test_input_schema(self, data, errors):\n resp = self.client.post(self.url, json=data)\n\n if not errors:\n assert resp.status_code == 200\n assert resp.get_json() == {\n 'status': 'OK',\n 'message': 'Data published via Upload service',\n }\n else:\n assert resp.status_code == 400\n assert resp.get_json() == {\n 'status': 'Error',\n 'message': 'Input payload validation failed',\n 'errors': {\n k: ['Missing data for required field.'] for k in errors\n },\n }","def validate_input(self, deposition, draft_id=None):\n v = APIValidator()\n draft_id = draft_id or deposition.get_default_draft_id()\n metadata_schema = deposition.type.api_metadata_schema(draft_id)\n\n if metadata_schema:\n schema = self.input_schema.copy()\n schema['metadata'] = metadata_schema\n else:\n schema = self.input_schema\n\n # Either conform to dictionary schema or dictionary is empty\n if not v.validate(request.json, schema) and \\\n request.json:\n abort(\n 400,\n message=\"Bad request\",\n status=400,\n errors=filter_validation_errors(v.errors),\n )","def test_validate_invalid_resume(self):\n # DEV: `validate` will raise an exception if it could not validate\n with self.assertRaises(jsonschema.ValidationError):\n resumeschema.validate(self.invalid_resume)","def validate(scheme, data):\n return validate_common(scheme, data)","def validate_index(self):\n schema_path = pkg_resources.resource_filename(\n \"FLIR.conservator\", \"index_schema.json\"\n )\n with open(schema_path) as o:\n schema = json.load(o)\n\n try:\n with open(self.index_path) as index:\n index_data = json.load(index)\n jsonschema.validate(index_data, schema)\n return True\n except jsonschema.exceptions.ValidationError as e:\n logger.error(e.message)\n logger.debug(e)\n return False","def test_validation_error_json():\n error = ValidationError(\n type=\"Syntax Error\",\n data={\"data\": [1, 2, 3]},\n )\n\n assert ValidationError(**json.loads(error.json())) == error","def validate(request, schema, variable_decode=True,\n variable_decode_dict_char=\".\", variable_decode_list_char=\"-\",\n context=None, data=None):\n\n if not data:\n try:\n data = request.json_body\n except ValueError:\n data = request.params\n\n if variable_decode is True:\n data = formencode.variabledecode.variable_decode(data,\n dict_char=variable_decode_dict_char,\n list_char=variable_decode_list_char)\n\n state = Dummyobj()\n state.request = request\n state.context = context\n\n schema = inspect.isclass(schema) and schema() or schema\n\n return schema.to_python(data, state=state)","def test_schema_valid(path, name, data):\n schemas = metaschemas()\n if name in ('release-schema.json', 'release-package-schema.json'):\n metaschema = schemas['release_package_metaschema']\n elif name == 'record-package-schema.json':\n metaschema = schemas['record_package_metaschema']\n elif name in ('project-schema.json', 'project-package-schema.json'):\n metaschema = schemas['project_package_metaschema']\n else:\n metaschema = schemas['metaschema']\n\n validate_json_schema(path, name, data, metaschema)","def validate(self, data):\n if data[\"start_time_period\"] > data[\"end_time_period\"]:\n raise serializers.ValidationError(\"End time can not be before start time\")\n elif (timezone.now() - data[\"end_time_period\"]) > timedelta(days=1):\n raise serializers.ValidationError(\"Weather can not be over 24 hours old\")\n elif data[\"end_time_period\"] > timezone.now():\n raise serializers.ValidationError(\"End time can not be in the future\")\n elif (data[\"end_time_period\"] - data[\"start_time_period\"]) >= timedelta(days=1):\n raise serializers.ValidationError(\"Only supports 1 day time frame for weather\")\n return data","def test_validate_business_schema():\n data = {\n 'business': {\n 'cacheId': 1,\n 'foundingDate': '2007-04-08T00:00:00+00:00',\n 'identifier': 'CP1234567',\n 'lastLedgerTimestamp': '2019-04-15T20:05:49.068272+00:00',\n 'lastPreBobFilingTimestamp': '2019-04-15T20:05:49.068272+00:00',\n 'legalName': 'legal name - CP1234567'\n },\n }\n\n is_valid, _ = validate(data, 'business', validate_schema=True)\n\n assert is_valid","def validate_json(func):\n\n # get the function name because we're going to\n # see if we need SCHEMA_POST, SCHEMA_GET, etc.\n function_name = func.__name__.upper()\n\n def wrapped_func(self, *args, **kwargs):\n respective_schema = getattr(self, 'SCHEMA_' + function_name)\n json_request = get_valid_json_or_abort(respective_schema)\n return func(self, json_request, *args, **kwargs)\n\n return wrapped_func","def validate(self):\n self.valid = True\n\n if self._value is None and self._strict:\n self.valid = False\n raise self.MissingFieldData\n\n elif self._value is not None:\n self._type_specific_validation()","def test_encode_errors(self):\n if self._cls == 'MetaschemaType':\n if self._invalid_validate:\n self.assert_raises(NotImplementedError, self.import_cls.encode,\n self._invalid_validate[0], self.typedef)\n else:\n if self._invalid_validate:\n self.assert_raises((ValueError,\n jsonschema.exceptions.ValidationError),\n self.import_cls.encode,\n self._invalid_validate[0], self.typedef)","def parse_json_or_fail(message, schema):\n try:\n body = tornado.escape.json_decode(message)\n except ValueError as e:\n raise tornado.web.HTTPError(400, reason=str(e))\n\n try:\n jsonschema.validate(body, schema)\n except jsonschema.exceptions.ValidationError as e:\n raise tornado.web.HTTPError(400, reason=e.message)\n\n return body","def validate(self, fqn, data, errors):\n\t\terrors.append(\"{}: validate() must be implemented for SchemaBase derived classes.\".format(self.__class__.__name__))\n\t\treturn False","def _validate(self):\n fields, schema = self.__dict__, self._def.default\n extra_fields = fields.viewkeys() - schema.viewkeys()\n if len(extra_fields) > 0:\n raise AttributeError('Fields found that are not in the schema: %r' % (list(extra_fields)))\n for key in fields.iterkeys():\n if type(fields[key]) is not type(schema[key]):\n raise AttributeError('Invalid %s for field \"%s\", should be %s' %\n (type(fields[key]), key, type(schema[key])))","def _validate_data(self, vms, fw_rules):\n self._validate_vms(vms)\n self._validate_fw_rules(fw_rules)\n self._validated = True","def validate_json(sub_domain, end_point_pattern, method, json_payload):\n if sub_domain not in REGISTER_INFO:\n return {\"errors\": ['invalid sub-domain']}\n # Get RAML resource\n raml = REGISTER_INFO[sub_domain][\"raml\"]\n raml_end_point = end_point_pattern.replace('<', '{').replace('>', '}')\n raml_resource = None\n for resource in raml.resources:\n if resource.path == raml_end_point and resource.method.lower() == method.lower():\n raml_resource = resource\n break\n if not raml_resource:\n return {\"errors\": ['cannot find RAML resource definition']}\n raml_schema = None\n # Get schema name from RAML resource\n if raml_resource.body:\n for body in raml_resource.body:\n if body.mime_type == \"application/json\":\n schema_name = body.schema\n for schema in raml.schemas:\n if schema_name in schema:\n raml_schema = schema[schema_name]\n break\n break\n if not raml_schema:\n return {\"errors\": ['cannot find schema in RAML resource definition']}\n # Load schema and validate against it\n try:\n validator = jsonschema.Draft4Validator(raml_schema, resolver=RELATIVE_RESOLVER)\n except jsonschema.SchemaError:\n return {\"errors\": ['invalid json schema']}\n errors = sorted(validator.iter_errors(json_payload), key=lambda e: e.path)\n error_return = []\n for error in errors:\n error_return.append(\"{}, {}\".format(str(list(error.schema_path)), error.message))\n for suberror in sorted(error.context, key=lambda e: e.schema_path):\n error_return.append(\"{}, {}\".format(str(list(suberror.schema_path)), suberror.message))\n return {\"errors\": error_return}","def validate_config(\n json_schema: JsonDict, config: Any, config_path: StrSequence\n) -> None:\n try:\n jsonschema.validate(config, json_schema)\n except jsonschema.ValidationError as e:\n raise json_error_to_config_error(e, config_path)","def validate(instance, schema, cls=None, *args, **kwargs):\r\n if cls is None:\r\n cls = validator_for(schema)\r\n cls.check_schema(schema)\r\n cls(schema, *args, **kwargs).validate(instance)","def _validate_json(self):\n # Do we find valid json?\n try:\n with open(self.batch_json_path, \"rb\") as fd:\n batch_json = json.loads(fd.read())\n\n except Exception as err:\n raise\n self.message(\n \"[-] Error reading JSON batch file '%s' : '%s'\" %\n (self.batch_json_path, err))\n return False\n\n # Does the json represent a dictionary of the expected form?\n if not isinstance(batch_json, types.DictionaryType):\n self.message(\n \"[-] JSON batch file '%s' deserialises to unexpected object type '%s'\" %\n (self.batch_json_path, type(batch_json)))\n return False\n\n # If it is a dictionary does it have the expected characteristics?\n for endpoint, sys_info in batch_json.items():\n\n # Endpoint should be a hostname, IP or some other string\n # identifier, difficult to validate much beyond 'string'\n if type(endpoint) not in [types.StringType, types.UnicodeType]:\n self.message(\n \"[-] Element within JSON batch file '%s' conatins unexpected object type for an endpoint element '%s'. %s : %s\" %\n (self.batch_json_path, type(endpoint), endpoint, sys_info))\n return False\n\n # Does the sys_info dict contain the expected keys?\n if set(sys_info.keys()).symmetric_difference(\n set(self.json_batch_template)):\n self.message(\n \"[-] Unexpected sys_info structure within JSON batch file %s, expected keys '%s' %s : %s\" %\n (self.batch_json_path, self.json_batch_template, endpoint, sys_info))\n return False\n\n # Create a psuedononymised hash of the uuid using MAC addr as salt\n mac_repr = \"0x\" + sys_info[\"mac_addr\"].lower().replace(\":\", \"\")\n sys_info[\"hashed_uuid\"] = hashlib.sha256(\n mac_repr + sys_info[\"sys_uuid\"]).hexdigest()\n\n # Remove both the real sys_uuid and the mac_addr from the structure so they do not get submitted to the API\n # and remain confidential to the submitter\n del sys_info[\"sys_uuid\"]\n del sys_info[\"mac_addr\"]\n\n # Set the read in json structure as the structure of system data to\n # walk and send to the API\n self.endpoints_to_check = batch_json\n\n self.message(\"[+] Batch JSON file validated\")\n return True","def validate(self, data):\n try:\n employee_rank = data['rank']\n except KeyError:\n employee_rank = 0\n\n try:\n supervisor_rank = data['supervisor'].rank\n except (AttributeError, KeyError):\n if employee_rank >= 0:\n return data\n else:\n raise serializers.ValidationError('Supervisor must have a rank')\n\n if employee_rank > supervisor_rank:\n raise serializers.ValidationError('Supervisor must have a higher rank than the Employee')\n return data"],"string":"[\n \"def validate(self, json_data):\\n self._errors = None\\n success = True\\n for item in self._schema:\\n if not item.validate(json_data):\\n success = False\\n\\n return success\",\n \"def validate_schema(*,\\n jsonschema: dict,\\n data: Any\\n ) -> None:\\n # from typing import TYPE_CHECKING\\n # if not TYPE_CHECKING:\\n # otherwise mypy raises error\\n # return\\n\\n _errors: defaultdict = defaultdict(list)\\n\\n def set_nested_item(data_dict, path, key, val): # type: ignore\\n for _key in path:\\n data_dict.setdefault(_key, {})\\n data_dict = data_dict[_key]\\n\\n data_dict.setdefault(key, list())\\n data_dict[key].append(val)\\n\\n for err in Draft7Validator(schema=jsonschema).iter_errors(instance=data):\\n path = err.schema_path\\n\\n if \\\"properties\\\" in path:\\n path.remove(\\\"properties\\\")\\n key = path.popleft()\\n\\n if \\\"required\\\" in path or key == \\\"required\\\":\\n key = err.message.split(\\\"'\\\")[1]\\n elif err.relative_path:\\n key = err.relative_path.pop()\\n\\n set_nested_item(_errors, err.relative_path, key, err.message)\\n\\n if _errors:\\n raise app_exceptions.ValidateDataError(dict(_errors))\",\n \"def validate_json_schema(self, json_schema):\\n cls = validators.validator_for(json_schema)\\n cls.check_schema(json_schema)\",\n \"def test_validate_json_validates_schema(self):\\n invalid_schema = {\\\"type\\\": \\\"any\\\"}\\n valid_json = {}\\n test_model = RecordSchema(schema=invalid_schema)\\n\\n with self.assertRaises(jsonschema.exceptions.SchemaError):\\n test_model.validate_json(valid_json)\",\n \"def test_validate_json(self):\\n # Lifted directly from the python-jsonschema docs\\n test_schema = {\\\"type\\\": \\\"object\\\",\\n \\\"properties\\\": {\\n \\\"price\\\": {\\\"type\\\": \\\"number\\\"},\\n \\\"name\\\": {\\\"type\\\": \\\"string\\\"},\\n }}\\n valid = {\\\"name\\\": \\\"Eggs\\\", \\\"price\\\": 34.99}\\n invalid = {\\\"name\\\": \\\"Eggs\\\", \\\"price\\\": \\\"Invalid\\\"}\\n\\n test_model = RecordSchema(schema=test_schema)\\n\\n self.assertIsNone(test_model.validate_json(valid))\\n\\n with self.assertRaises(jsonschema.exceptions.ValidationError):\\n test_model.validate_json(invalid)\",\n \"def check_valid_schema(context):\\n data = context.response.json()\\n validate_schema(data)\",\n \"def validate_schema(self, schema):\\n json_schema_path = os.path.join(_ROOT, 'data', 'schema.json')\\n json_schema = load_json_or_yaml(json_schema_path)\\n return validate(schema, json_schema)\",\n \"def validate_data(schema_cls: Serializer, data: dict) -> dict:\\n schema = schema_cls(data=data)\\n schema.is_valid(raise_exception=True)\\n return schema.validated_data\",\n \"def validate_against_schema(request, schema, data):\\n try:\\n data_pure = schema.deserialize(data)\\n data_clean = post_serialize(data_pure)\\n # Attach data_clean to request: see usage in views.\\n request.data_clean = data_clean\\n except Invalid as e:\\n # here we transform the errors we got from colander into cornice\\n # errors\\n for field, error in e.asdict().items():\\n request.errors.add('body', field, error)\",\n \"def validate(self, json_data):\\n try:\\n self.process_json(json_data)\\n except ValueError as e:\\n # self.process_errors.append(e.args[0])\\n self.process_errors = [e.args[0]]\\n\\n self.errors = list(self.process_errors)\\n\\n # Run validators\\n if not self.errors:\\n chain = itertools.chain(self.validators)\\n self._run_validation_chain(chain)\\n\\n return len(self.errors) == 0\",\n \"def validator(data_json):\\n fields = spec[\\\"fields\\\"]\\n data = json.loads(data_json, object_pairs_hook=collections.OrderedDict)\\n for k, v in fields.items():\\n if v.get(\\\"required\\\"):\\n found = False\\n if k in data:\\n found = True\\n elif \\\".\\\" in k:\\n # Dotted keys could be nested, like ecs.version\\n subkeys = k.split(\\\".\\\")\\n subval = data\\n for subkey in subkeys:\\n subval = subval.get(subkey, {})\\n if subval:\\n found = True\\n if not found:\\n raise ValidationError(\\\"Missing required key {}\\\".format(k))\\n if k in data:\\n if v[\\\"type\\\"] == \\\"string\\\" and not (\\n isinstance(data[k], str) or isinstance(data[k], basestring)\\n ):\\n raise ValidationError(\\n \\\"Value {0} for key {1} should be string, is {2}\\\".format(\\n data[k], k, type(data[k])\\n )\\n )\\n if v[\\\"type\\\"] == \\\"datetime\\\":\\n try:\\n datetime.datetime.strptime(data[k], \\\"%Y-%m-%dT%H:%M:%S.%fZ\\\")\\n except ValueError:\\n raise ValidationError(\\n \\\"Value {0} for key {1} doesn't parse as an ISO datetime\\\".format(\\n data[k], k\\n )\\n )\\n if v.get(\\\"index\\\") and list(data.keys())[v.get(\\\"index\\\")] != k:\\n raise ValidationError(\\\"Key {0} is not at index {1}\\\".format(k, index))\\n\\n return data_json\",\n \"def validate_against_schema(self, json_doc):\\n if self.uri not in self.se.validation:\\n raise RuntimeError(\\\"$validation is not defined for {} field; thus the json document could not be validated\\\".format(self.name))\\n else:\\n validate(json_doc, self.se.validation[self.uri])\\n print('The JSON document is valid')\",\n \"def validate_json(self):\\n pass\",\n \"def validate(cls, data, schema=None):\\n if data is None:\\n raise APIError(\\n \\\"Data of the apartment to be created must be passed a json body\\\",\\n status=400,\\n )\\n\\n try:\\n if schema is None:\\n return data\\n\\n return schema.load(data)\\n except ValidationError as error:\\n raise APIError(\\n \\\"Error validating input data\\\", causes=error.messages\\n ) from error\",\n \"def validate_json(self, data, schema):\\n validator = jsonschema.Draft7Validator(schema, format_checker=jsonschema.draft7_format_checker)\\n errors = validator.iter_errors(data)\\n error_list = [(error.message, str(error.path), error) for error in errors]\\n return error_list\",\n \"def is_json_valid(json_data: dict, json_schema: dict) -> bool:\\r\\n try:\\r\\n validate(instance=json_data, schema=json_schema)\\r\\n except jsonschema.exceptions.ValidationError as err:\\r\\n return False\\r\\n return True\",\n \"def assert_valid_schema(data, schema_file):\\n\\n schema = _load_json_schema(schema_file)\\n return validate(data, schema)\",\n \"def _validate(self):\\n schema_version = util.schemas[self.schema_name]\\n stored_schemas = util.stored_schemas\\n\\n try:\\n schema_obj = stored_schemas[\\n \\\"http://redfish.dmtf.org/schemas/v1/\\\" + schema_version]\\n except KeyError:\\n raise OneViewRedfishError(\\\"{} not found\\\".format(schema_version))\\n\\n resolver = jsonschema.RefResolver('', schema_obj, store=stored_schemas)\\n jsonschema.validate(self.redfish, schema_obj, resolver=resolver)\",\n \"def validate_json_schema(path, name, data, schema, full_schema=not is_extension):\\n errors = 0\\n\\n # The standard repository has an example extension.\\n if 'docs/examples/organizations/organizational_units/ocds_divisionCode_extension' in path:\\n full_schema = False\\n\\n # Kingfisher Collect uses JSON Schema files to validate Scrapy items.\\n code_repo = repo_name == 'kingfisher-collect'\\n\\n # Non-OCDS schema don't:\\n # * pair \\\"enum\\\" and \\\"codelist\\\"\\n # * disallow \\\"null\\\" in \\\"type\\\" of \\\"items\\\"\\n # * UpperCamelCase definitions and lowerCamelCase properties\\n # * allow \\\"null\\\" in the \\\"type\\\" of optional fields\\n # * include \\\"id\\\" fields in objects within arrays\\n # * require \\\"title\\\", \\\"description\\\" and \\\"type\\\" properties\\n json_schema_exceptions = {\\n 'json-schema-draft-4.json',\\n 'meta-schema.json',\\n 'meta-schema-patch.json',\\n }\\n ocds_schema_exceptions = {\\n 'dereferenced-release-schema.json',\\n # standard-maintenance-scripts\\n 'codelist-schema.json',\\n 'extension-schema.json',\\n # extension_registry\\n 'extensions-schema.json',\\n 'extension_versions-schema.json',\\n # spoonbill\\n 'ocds-simplified-schema.json',\\n }\\n schema_exceptions = json_schema_exceptions | ocds_schema_exceptions\\n\\n validate_items_type_kwargs = {\\n 'allow_invalid': {\\n '/definitions/Amendment/properties/changes/items', # deprecated\\n '/definitions/AmendmentUnversioned/properties/changes/items', # deprecated\\n '/definitions/record/properties/releases/oneOf/0/items', # 1.1\\n },\\n }\\n\\n def validate_codelist_enum_allow_missing(codelist):\\n return is_extension and codelist in external_codelists\\n\\n validate_codelist_enum_kwargs = {\\n 'fallback': {\\n '/definitions/Metric/properties/id': ['string'],\\n '/definitions/Milestone/properties/code': ['string', 'null'],\\n },\\n 'allow_missing': validate_codelist_enum_allow_missing,\\n }\\n\\n validate_letter_case_kwargs = {\\n 'property_exceptions': {'former_value'}, # deprecated\\n 'definition_exceptions': {'record'}, # 1.1\\n }\\n\\n def validate_metadata_presence_allow_missing(pointer):\\n return 'links' in pointer.split('/') or code_repo # ocds_pagination_extension\\n\\n validate_metadata_presence_kwargs = {\\n 'allow_missing': validate_metadata_presence_allow_missing,\\n }\\n\\n def validate_object_id_allow_missing(pointer):\\n parts = pointer.split('/')\\n return 'versionedRelease' in parts or parts[-1] in {\\n 'changes', # deprecated\\n 'records', # uses `ocid` not `id`\\n '0', # linked releases\\n }\\n\\n validate_object_id_kwargs = {\\n 'allow_missing': validate_object_id_allow_missing,\\n 'allow_optional': {\\n # 2.0 fixes.\\n # See https://github.com/open-contracting/standard/issues/650\\n '/definitions/Amendment',\\n '/definitions/Organization',\\n '/definitions/OrganizationReference',\\n '/definitions/RelatedProcess',\\n },\\n }\\n if repo_name == 'infrastructure':\\n validate_object_id_kwargs['allow_optional'].add('/definitions/Classification')\\n\\n validate_null_type_kwargs = {\\n # OCDS allows null. OC4IDS disallows null.\\n 'no_null': repo_name == 'infrastructure' or code_repo,\\n 'allow_object_null': {\\n '/definitions/Amendment/properties/changes/items/properties/former_value', # deprecated\\n # See https://github.com/open-contracting/standard/pull/738#issuecomment-440727233\\n '/definitions/Organization/properties/details',\\n },\\n 'allow_no_null': {\\n '/definitions/Amendment/properties/changes/items/properties/property', # deprecated\\n\\n # Children of fields with omitWhenMerged.\\n '/definitions/Link/properties/rel',\\n '/definitions/Link/properties/href',\\n\\n # 2.0 fixes.\\n # See https://github.com/open-contracting/standard/issues/650\\n '/definitions/Organization/properties/id',\\n '/definitions/OrganizationReference/properties/id',\\n '/definitions/RelatedProcess/properties/id',\\n },\\n }\\n\\n validate_array_items_kwargs = {\\n 'allow_invalid': {\\n '/definitions/Amendment/properties/changes/items/properties/former_value', # deprecated\\n '/definitions/Location/properties/geometry/properties/coordinates/items', # recursion\\n },\\n }\\n\\n validate_deep_properties_kwargs = {\\n 'allow_deep': {\\n '/definitions/Amendment/properties/changes/items', # deprecated\\n },\\n }\\n if is_extension: # avoid repetition in extensions\\n validate_deep_properties_kwargs['allow_deep'].add('/definitions/Item/properties/unit')\\n\\n validator = Draft4Validator(schema, format_checker=FormatChecker())\\n\\n errors += validate_schema(path, data, validator)\\n if errors:\\n warnings.warn(f'{path} is not valid JSON Schema ({errors} errors)')\\n\\n if name not in schema_exceptions:\\n if 'versioned-release-validation-schema.json' in path:\\n validate_items_type_kwargs['additional_valid_types'] = ['object']\\n errors += validate_array_items(path, data, **validate_array_items_kwargs)\\n errors += validate_items_type(path, data, **validate_items_type_kwargs)\\n if not code_repo:\\n errors += validate_codelist_enum(path, data, **validate_codelist_enum_kwargs)\\n errors += validate_letter_case(path, data, **validate_letter_case_kwargs)\\n errors += validate_merge_properties(path, data)\\n\\n # `full_schema` is set to not expect extensions to repeat information from core.\\n if full_schema:\\n exceptions_plus_versioned = schema_exceptions | {\\n 'versioned-release-validation-schema.json',\\n }\\n\\n exceptions_plus_versioned_and_packages = exceptions_plus_versioned | {\\n 'project-package-schema.json',\\n 'record-package-schema.json',\\n 'release-package-schema.json',\\n }\\n\\n if not code_repo:\\n # Extensions aren't expected to repeat referenced `definitions`.\\n errors += validate_ref(path, data)\\n\\n if name not in exceptions_plus_versioned:\\n # Extensions aren't expected to repeat `title`, `description`, `type`.\\n errors += validate_metadata_presence(path, data, **validate_metadata_presence_kwargs)\\n if not code_repo:\\n # Extensions aren't expected to repeat referenced `definitions`.\\n errors += validate_object_id(path, jsonref.replace_refs(data), **validate_object_id_kwargs)\\n\\n if name not in exceptions_plus_versioned_and_packages:\\n # Extensions aren't expected to repeat `required`. Packages don't have merge rules.\\n errors += validate_null_type(path, data, **validate_null_type_kwargs)\\n # Extensions aren't expected to repeat referenced codelist CSV files\\n # TODO: This code assumes each schema uses all codelists. So, for now, skip package schema.\\n errors += validate_schema_codelists_match(path, data, cwd, is_extension, is_profile, external_codelists)\\n\\n else:\\n # Don't count these as errors.\\n validate_deep_properties(path, data, **validate_deep_properties_kwargs)\\n\\n assert not errors, 'One or more JSON Schema files are invalid. See warnings below.'\",\n \"def validate(schema):\\n def decorator(func):\\n def wrapper(self, req, resp, *args, **kwargs):\\n try:\\n raw_json = req.stream.read()\\n obj = json.loads(raw_json.decode('utf-8'))\\n obj['req_id'] = req.context.get('request_id')\\n except Exception:\\n raise falcon.HTTPBadRequest(\\n title='Invalid data',\\n description='Could not properly parse the provided data as JSON',\\n code='001'\\n )\\n\\n try:\\n jsonschema.validate(obj, schema)\\n except jsonschema.ValidationError as e:\\n raise falcon.HTTPBadRequest(\\n title='Failed data validation',\\n description=e.message,\\n code='002'\\n )\\n\\n return func(self, req, resp, *args, parsed=obj, **kwargs)\\n return wrapper\\n return decorator\",\n \"def validateJSON(jsonData):\\n try:\\n json.loads(jsonData)\\n validate(instance=json.loads(jsonData), schema=read_json_schema(schema_file_path))\\n except Exception as err:\\n logging.error(err)\\n logging.info(\\\" Message received is not correct \\\")\\n logging.info(\\\" Message sent to Pulsar Rejection Topic for reprocessing\\\")\\n # IF a message is not correct, I prefer to stop the consumer and fix the problem. Another way will be to\\n # Send message to another to topic if the message is not valid and change raise below by pass.\\n raise\\n return False\\n\\n return True\",\n \"def validator(request, schema):\\n try:\\n body = request.body.decode('utf-8')\\n dictbody = json.loads(body) if body else {}\\n validate_against_schema(request, schema, dictbody)\\n except ValueError as e:\\n request.errors.add('body', 'body', six.text_type(e))\",\n \"def validate_json(schema, doc):\\n is_invalid = set(doc).difference(set(schema))\\n if is_invalid:\\n return False\\n return True\",\n \"def validate(obj, schema=PROCESSING_SERVER_CONFIG_SCHEMA):\\n return JsonValidator.validate(obj, schema)\",\n \"def validate(self) -> None:\\n schema = type(self).schema\\n if schema:\\n if self.data is None:\\n raise PresenterException(\\\"No data given.\\\")\\n try:\\n schema(self.data)\\n except JsonSchemaException as exception:\\n raise PresenterException(exception.message)\\n else:\\n if self.data is not None:\\n raise PresenterException(\\\"This presenter does not take data.\\\")\",\n \"def assert_valid_schema(data, schemafile):\\n\\n schema = _load_json_schema(schemafile)\\n return validate(data, schema)\",\n \"def validate(cls, data, errors):\",\n \"def decide_schema(self, json_data):\\n pass\",\n \"def decide_schema(self, json_data):\\n pass\",\n \"def validate(data):\\n try:\\n return Schema(Validator.SCHEMA).validate(data)\\n except SchemaError as exception:\\n logging.getLogger(__name__).error(exception)\\n return None\",\n \"def test_validate_schema():\\n data = {\\n 'business': {\\n 'cacheId': 1,\\n 'foundingDate': '2007-04-08T00:00:00+00:00',\\n 'identifier': 'CP1234567',\\n 'legalName': 'legal name CP1234567'\\n },\\n }\\n\\n is_valid, _ = validate(data, 'business', validate_schema=True)\\n\\n assert is_valid\",\n \"def validate(self, data):\\n age = data.get(\\\"age\\\", None)\\n age = age.split(\\\",\\\")\\n size = data.get(\\\"size\\\", None)\\n size = size.split(\\\",\\\")\\n gender = data.get(\\\"gender\\\", None)\\n gender = gender.split(\\\",\\\")\\n for i in age:\\n if i not in ['b', 'y', 'a', 's']:\\n raise serializers.ValidationError(\\n \\\"Age must be either 'b' for baby, 'y' for young,\\\"\\n \\\" 'a' for adult, or 's' for senior. Can do multiple with\\\"\\n \\\" commas, ex: a,y,e\\\")\\n for i in size:\\n if i not in ['s', 'm', 'l', 'xl']:\\n raise serializers.ValidationError(\\n \\\"Size must be either 's' for small, 'm' for medium, 'l' \\\"\\n \\\"for large, or 'xl' for extra large. Can do multiple with\\\"\\n \\\" commas, ex: s,l,xl\\\")\\n for i in gender:\\n if i not in ['m', 'f']:\\n raise serializers.ValidationError(\\n \\\"Gender must be either 'm' for male, or 'f' for female. Can\\\"\\n \\\" have both using commas, ex: m,f\\\")\\n return data\",\n \"def validate(json_resp, schema, validictory_path, schema_base=None):\\n # assumes /extern/validictory exists (see /cm for instructions)\\n if not validictory_path in sys.path:\\n sys.path.append(validictory_path)\\n import validictory\\n\\n try:\\n if schema_base and not json_resp[\\\"$schema\\\"].startswith(schema_base):\\n print \\\"Warning: JSON schema is \\\", json_resp[\\\"$schema\\\"], \\\"instead of \\\", schema_base\\n validictory.validate(json_resp, schema, required_by_default=False)\\n return True\\n except Exception as e:\\n print \\\"Received exception %s while trying to validate: %s\\\" % (\\n str(e), json_resp)\\n return False\",\n \"def validate_schema(schema):\\n def decorator(func):\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n\\n try:\\n validate(request.json, schema)\\n except:\\n return bad_request()\\n\\n return func(*args, **kwargs)\\n\\n return wrapper\\n\\n return decorator\",\n \"def test_invalid_schema():\\n # setup\\n uid = uuid.uuid4()\\n schema_dir = f'/tmp/{uid}'\\n schema_file = f'{schema_dir}/bad_schema.json'\\n os.makedirs(schema_dir)\\n text_file = open(schema_file, 'w')\\n text_file.write('this will fail[];fail()')\\n text_file.close()\\n\\n data = {}\\n\\n # test\\n is_valid, errors = validate(data, 'bad_schema', validate_schema=True)\\n\\n # teardown\\n os.remove(schema_file)\\n os.removedirs(schema_dir)\\n\\n assert not is_valid\\n assert errors\",\n \"def validate(data, schema, resolver):\\n try:\\n # if valid returns None\\n return Draft7Validator(schema=schema, resolver=resolver).validate(data)\\n except ValidationError:\\n raise ValidationError(\\\"data couldn't be validated.\\\")\\n except RefResolutionError:\\n raise RefResolutionError(\\\"schema references couldn't be solved.\\\")\",\n \"def validate_insert_json(request_json):\\n try:\\n jsonschema.validate(request_json, schema_input)\\n except (jsonschema.exceptions.ValidationError, jsonschema.exceptions.SchemaError, JSONDecodeError) as e:\\n current_app.logger.info(\\\"Invalid json:{}\\\".format(str(e)))\\n raise (InvalidJSONError(\\\"Invalid json:{}\\\".format(str(e))))\",\n \"def validate_property_schema(self, schema):\\n json_schema_path = os.path.join(_ROOT,\\n 'data',\\n 'property_json_schema.json')\\n json_schema = load_json_or_yaml(json_schema_path)\\n return validate(schema, json_schema)\",\n \"def validate(json_data: json,\\n schema_id: str,\\n schema_store: dict = None,\\n validate_schema: bool = False,\\n schema_search_path: str = None\\n ) -> Tuple[bool, iter]:\\n try:\\n if not schema_search_path:\\n schema_search_path = path.join(path.dirname(__file__), 'schemas')\\n\\n if not schema_store:\\n schema_store = get_schema_store(validate_schema, schema_search_path)\\n\\n schema = schema_store.get(f'{BASE_URI}/{schema_id}')\\n if validate_schema:\\n Draft7Validator.check_schema(schema)\\n\\n schema_file_path = path.join(schema_search_path, schema_id)\\n resolver = RefResolver(f'file://{schema_file_path}.json', schema, schema_store)\\n\\n if Draft7Validator(schema,\\n format_checker=Draft7Validator.FORMAT_CHECKER,\\n resolver=resolver\\n ) \\\\\\n .is_valid(json_data):\\n return True, None\\n\\n errors = Draft7Validator(schema,\\n format_checker=Draft7Validator.FORMAT_CHECKER,\\n resolver=resolver\\n ) \\\\\\n .iter_errors(json_data)\\n return False, errors\\n\\n except SchemaError as error:\\n # handle schema error\\n return False, error\",\n \"def validate(document, schema=\\\"ctsa::bts:CTSADataset\\\"):\\n try:\\n document = ensure_document(document)\\n schema = ensure_schema(schema)\\n\\n except (TypeError, ValueError) as err:\\n raise DatasetValidationError(err)\\n\\n try:\\n validator = jsonschema.Draft7Validator(schema)\\n if not validator.is_valid(document):\\n errors = []\\n for error in sorted(validator.iter_errors(document), key=str):\\n errors.append(error.message)\\n raise DatasetJsonSchemaValidationError(errors)\\n except jsonschema.exceptions.SchemaError as err: #Invalid Schema\\n raise DatasetJsonSchemaValidationError(err)\\n except jsonschema.exceptions.ValidationError as err: #Invalid Doc\\n raise DatasetJsonSchemaValidationError(err)\\n except Exception as exc: # unexpected errors\\n raise DatasetValidationError(str(exc))\\n\\n return ValidatedDict(document)\",\n \"def validate_api_resp(actual_json_resp, json_schema_path: str, json_schema_file_name):\\n with open(os.path.join(JSON_SCHEMA_ROOT, json_schema_path, json_schema_file_name), 'r') as f:\\n json_schema = json.loads(f.read())\\n actual_json = json.loads(str(actual_json_resp.data, 'utf-8'))\\n jsonschema.validate(actual_json, json_schema)\",\n \"def schema_validation(schema):\\n def decorator(function):\\n @wraps(function)\\n def wrapper(*args, **kwargs):\\n data = {}\\n if request.method in ['POST', 'PATCH', 'PUT']:\\n data = request.get_json(force=True)\\n elif request.method in ['GET', 'DELETE']:\\n data = request.args.to_dict()\\n\\n v = Validator(schema)\\n v.allow_unknown = True\\n if v.validate(data):\\n return function(*args, **kwargs)\\n else:\\n return jsonify({'errors': v.errors}), 400\\n\\n return wrapper\\n return decorator\",\n \"def validate_data(self, data):\\n # TODO use schema\\n assert \\\"file_contents\\\" in data, data\\n assert \\\"type\\\" in data, data\",\n \"def isValidForSchema(schema):\\n\\n return True\",\n \"def validate_with(schema):\\n def decorator(f):\\n @functools.wraps(f)\\n def wrapper(*args, **kwargs):\\n if not (request.json or request.data or request.form):\\n flask_restful.abort(400, message='Validation error.',\\n errors=['No data provided.'])\\n try:\\n data = schema(prepare_request_data(request))\\n except voluptuous.MultipleInvalid as err:\\n flask_restful.abort(400,\\n message='Validation error.',\\n errors=[str(e) for e in err.errors])\\n setattr(request, 'validated_body', data)\\n return f(*args, **kwargs)\\n return wrapper\\n return decorator\",\n \"def validate_json(data: dict) -> bool:\\n try:\\n assert \\\"data\\\" in data.keys()\\n assert isinstance(data[\\\"data\\\"], str)\\n assert \\\"command\\\" in data.keys()\\n assert isinstance(data[\\\"command\\\"], str)\\n assert \\\"time\\\" in data.keys()\\n assert isinstance(data[\\\"time\\\"], str)\\n assert \\\"origin\\\" in data.keys()\\n assert isinstance(data[\\\"origin\\\"], str)\\n return True\\n except AssertionError:\\n return False\",\n \"def validate_payload(cls, event):\\n # TODO: Use invenio-jsonschemas/jsonresolver instead of this\\n # Validate against Event JSONSchema\\n # NOTE: raises `jsonschemas.ValidationError`\\n cls._jsonschema_validator.validate(event)\\n\\n # Validate using marshmallow loader\\n for payload in event:\\n errors = RelationshipSchema(check_existing=True).validate(payload)\\n if errors:\\n raise MarshmallowValidationError(str(errors) + \\\"payload\\\" + str(payload))\",\n \"def assertValidJSON(self, data):\\r\\n # Just try the load. If it throws an exception, the test case will fail.\\r\\n self.serializer.from_json(data)\",\n \"def test_schema_invalid_json(self):\\n schema_0_input = schema_nested_2_invalid_JSON\\n\\n # if you uncomment this line:\\n # schema_0_input = schema_nested_2\\n # this will fail the test: Failed: DID NOT RAISE <class 'simplejson.scanner.JSONDecodeError'>\\n # because this is a valid schema\\n\\n with pytest.raises(simplejson.scanner.JSONDecodeError):\\n msg = singer.parse_message(schema_0_input)\",\n \"def validate_class_schema(self, schema):\\n json_schema_path = os.path.join(_ROOT,\\n 'data',\\n 'class_json_schema.json')\\n json_schema = load_json_or_yaml(json_schema_path)\\n return validate(schema, json_schema)\",\n \"def validator(data):\\n\\n request_validator = cerberus.Validator(SCHEMA)\\n if request_validator.validate(data):\\n return True\\n else:\\n return request_validator.errors\",\n \"def validate(self, schema=None, callback=None):\\n return hxl.schema(schema, callback).validate(self)\",\n \"def validate(self, config_json):\\n pass\",\n \"def testCheck(self):\\r\\n from pydsl.Grammar.Definition import JsonSchema\\r\\n from pydsl.Check import JsonSchemaChecker\\r\\n schema = {\\r\\n \\\"type\\\" : \\\"string\\\",\\r\\n \\\"items\\\" : {\\r\\n \\\"type\\\" : [\\\"string\\\", \\\"object\\\"],\\r\\n \\\"properties\\\" : {\\r\\n \\\"foo\\\" : {\\\"enum\\\" : [1, 3]},\\r\\n #\\\"bar\\\" : { #See https://github.com/Julian/jsonschema/issues/89\\r\\n # \\\"type\\\" : \\\"array\\\",\\r\\n # \\\"properties\\\" : {\\r\\n # \\\"bar\\\" : {\\\"required\\\" : True},\\r\\n # \\\"baz\\\" : {\\\"minItems\\\" : 2},\\r\\n # }\\r\\n #}\\r\\n }\\r\\n }\\r\\n }\\r\\n grammardef = JsonSchema(schema)\\r\\n checker = JsonSchemaChecker(grammardef)\\r\\n self.assertTrue(checker.check(\\\"a\\\"))\\r\\n self.assertFalse(checker.check([1, {\\\"foo\\\" : 2, \\\"bar\\\" : {\\\"baz\\\" : [1]}}, \\\"quux\\\"]))\",\n \"def validate(validator, document):\\n try:\\n validator.validate(document)\\n except jsonschema.ValidationError as ex:\\n raise wsgi_errors.HTTPBadRequestBody(\\n '{0}: {1}'.format(ex.args, ex.message)\\n )\",\n \"def validate(self) -> bool:\\n\\n # Start by reading in the blueprint schema json\\n schema = json.loads(pkgutil.get_data(\\\"FactorioTools\\\", \\\"blueprintSchema.json\\\"))\\n\\n # Validate the object's schema against the blueprintSchema JSON\\n try:\\n jsonschema.validate(self.data, schema)\\n return True\\n except jsonschema.ValidationError:\\n pass\\n\\n return False\",\n \"def check_schema(body, schema):\\n validator = jsonschema.Draft4Validator(\\n schema, format_checker=jsonschema.FormatChecker())\\n try:\\n validator.validate(body)\\n except jsonschema.ValidationError as exc:\\n raise exception.InvalidParameterValue(_('Invalid create body: %s') %\\n exc)\",\n \"def validate(\\n instance: typing.Union[typing.Dict[str, typing.Any], typing.List[typing.Any]],\\n schema: typing.Dict[str, typing.Any],\\n path: typing.Optional[typing.List[str]] = None,\\n allow_disabled_languages: bool = False,\\n strict: bool = False\\n) -> None:\\n if path is None:\\n path = []\\n if not isinstance(schema, dict):\\n raise ValidationError('invalid schema (must be dict)', path)\\n if 'type' not in schema:\\n raise ValidationError('invalid schema (must contain type)', path)\\n if schema['type'] == 'array' and isinstance(instance, list):\\n return _validate_array(instance, schema, path, allow_disabled_languages=allow_disabled_languages, strict=strict)\\n elif schema['type'] == 'object' and isinstance(instance, dict):\\n return _validate_object(instance, schema, path, allow_disabled_languages=allow_disabled_languages, strict=strict)\\n elif schema['type'] == 'text' and isinstance(instance, dict):\\n return _validate_text(instance, schema, path, allow_disabled_languages=allow_disabled_languages)\\n elif schema['type'] == 'datetime' and isinstance(instance, dict):\\n return _validate_datetime(instance, schema, path)\\n elif schema['type'] == 'bool' and isinstance(instance, dict):\\n return _validate_bool(instance, schema, path)\\n elif schema['type'] == 'quantity' and isinstance(instance, dict):\\n return _validate_quantity(instance, schema, path)\\n elif schema['type'] == 'sample' and isinstance(instance, dict):\\n return _validate_sample(instance, schema, path)\\n elif schema['type'] == 'measurement' and isinstance(instance, dict):\\n return _validate_measurement(instance, schema, path)\\n elif schema['type'] == 'object_reference' and isinstance(instance, dict):\\n return _validate_object_reference(instance, schema, path)\\n elif schema['type'] == 'tags' and isinstance(instance, dict):\\n return _validate_tags(instance, schema, path, strict=strict)\\n elif schema['type'] == 'hazards' and isinstance(instance, dict):\\n return _validate_hazards(instance, schema, path)\\n elif schema['type'] == 'user' and isinstance(instance, dict):\\n return _validate_user(instance, schema, path)\\n elif schema['type'] == 'plotly_chart' and isinstance(instance, dict):\\n return _validate_plotly_chart(instance, schema, path)\\n else:\\n raise ValidationError('invalid type', path)\",\n \"def validate(self, data):\\n raise NotImplementedError(\\\"Inherit this class and override this method.\\\")\",\n \"def validate(self, data):\\n gender = data.get(\\\"gender\\\", None)\\n size = data.get(\\\"size\\\", None)\\n if gender not in ['m', 'f', 'u']:\\n raise serializers.ValidationError(\\n \\\"Gender must be either 'm' for male, 'f' \\\"\\n \\\"for female, or 'u' for unknown.\\\")\\n elif size not in ['s', 'm', 'l', 'xl', 'u']:\\n raise serializers.ValidationError(\\n \\\"Size must be 's' for small, 'm' for medium, 'l' for large,\\\"\\n \\\" 'xl' for extra large, or 'u' for unknown.\\\")\\n return data\",\n \"def validate(schema, record):\\n if six.PY3:\\n return Utils._py3_validate(schema, record)\\n else:\\n return Utils._py2_validate(schema, record)\",\n \"def validate_datasets(row):\\n data_validator = DataJSONDataset(row)\\n valid = data_validator.validate(validator_schema=row['validator_schema'])\\n errors = data_validator.errors\\n row['validation_errors'] = errors\\n if not valid:\\n logger.error(f'Error validating {row}: {errors}')\",\n \"def validate_schema(payload, schema):\\n errors = []\\n validator = jsonschema.Draft4Validator(schema,\\n format_checker=jsonschema.FormatChecker())\\n for error in sorted(validator.iter_errors(payload), key=str):\\n errors.append(error.message)\\n\\n return errors\",\n \"def test_jsonschema_validation_with_schema_object(self):\\n check_value = {\\\"a\\\": 1}\\n schema = {\\n \\\"type\\\": \\\"object\\\",\\n \\\"properties\\\": {\\n \\\"a\\\": {\\n \\\"type\\\": \\\"integer\\\",\\n \\\"const\\\": 1\\n }\\n }\\n }\\n jsonschema_validation(check_value, schema)\",\n \"def validate_schema(self, data, **kwargs):\\n if \\\"role\\\" not in data and \\\"visible\\\" not in data:\\n raise ValidationError(_(\\\"Missing fields 'role' and/or 'visible'.\\\"))\",\n \"def handle_marshmallow_validaton(err): # except ValidationError as err\\n return jsonify(err.messages), 400 # bad request\",\n \"def _verify_schema(schema):\\n assert type(schema) in [dict, tuple], f'Expected a dict or a tuple but got {type(schema)}'\\n if isinstance(schema, tuple):\\n assert len(schema) == 2, f'Expected a tuple with length 2 but got length {len(schema)}'\\n if schema[1] is not None:\\n assert isinstance(schema[1], schema[0]), f'{str(schema[1])} does not have expected type {str(schema)}'\\n elif isinstance(schema, dict):\\n for sub_schema in schema.values():\\n _verify_schema(sub_schema)\",\n \"def validate(self, value):\\n if isinstance(value, dict):\\n if set(value.keys()) == {\\\"type\\\", \\\"coordinates\\\"}:\\n if value[\\\"type\\\"] != self._type:\\n self.error(f'{self._name} type must be \\\"{self._type}\\\"')\\n return self.validate(value[\\\"coordinates\\\"])\\n else:\\n self.error(\\n \\\"%s can only accept a valid GeoJson dictionary\\\"\\n \\\" or lists of (x, y)\\\" % self._name\\n )\\n return\\n elif not isinstance(value, (list, tuple)):\\n self.error(\\\"%s can only accept lists of [x, y]\\\" % self._name)\\n return\\n\\n validate = getattr(self, \\\"_validate_%s\\\" % self._type.lower())\\n error = validate(value)\\n if error:\\n self.error(error)\",\n \"def valid(schema=None):\\n def dec(fun):\\n @wraps(fun)\\n def d_func(self, ctx, data, *a, **kw):\\n try:\\n validate(data['params'], schema)\\n except ValidationError as err:\\n raise InvalidParams(err)\\n except SchemaError as err:\\n raise InternalError(err)\\n return fun(self, ctx, data['params'], *a, **kw)\\n return d_func\\n return dec\",\n \"def validate(data):\\n if 'value' not in data or \\\\\\n 'category' not in data or \\\\\\n 'classification' not in data or \\\\\\n 'account' not in data:\\n raise Exception('Missing required field.')\\n classifications = ['Personal', 'Essential', 'Savings', 'Income']\\n if data['classification'] not in classifications:\\n raise Exception('Invalid classification.')\",\n \"def validate(self, descriptor, schema_id):\\n try:\\n jsonschema.validate(descriptor, self.load_schema(schema_id))\\n return True\\n\\n except ValidationError as e:\\n log.error(\\\"Failed to validate Descriptor against schema '{}'\\\"\\n .format(schema_id))\\n self.error_msg = e.message\\n log.error(e.message)\\n return\\n\\n except SchemaError as e:\\n log.error(\\\"Invalid Schema '{}'\\\".format(schema_id))\\n self.error_msg = e.message\\n log.debug(e)\\n return\",\n \"def validate(mapping: Mapping[str, Any], ref: str) -> List[SchemaError]:\\n # pylint: disable=too-many-branches\\n\\n valid_err = None # type: Optional[jsonschema.ValidationError]\\n try:\\n jsonschema.validate(instance=mapping, schema=mapry.schemas.GRAPH)\\n except jsonschema.ValidationError as err:\\n valid_err = err\\n\\n if valid_err is not None:\\n return [\\n SchemaError(\\n message=\\\"Does not follow json schema: {}\\\".format(\\n valid_err.message),\\n ref='/'.join([ref] + [str(part) for part in valid_err.path]))\\n ]\\n\\n errors = [] # type: List[SchemaError]\\n\\n # Enforce name and description to be at the top of the schema\\n if isinstance(mapping, collections.OrderedDict):\\n mapping_keys = list(mapping.keys())\\n\\n if mapping_keys[0] != 'name':\\n errors.append(\\n SchemaError(\\n message=(\\n \\\"Expected name to be the first property of the schema, \\\"\\n \\\"but got {}\\\").format(mapping_keys[0]),\\n ref='{}/name'.format(ref)))\\n\\n if mapping_keys[1] != 'description':\\n errors.append(\\n SchemaError(\\n message=(\\n \\\"Expected description to be the second property \\\"\\n \\\"of the schema, but got {}\\\").format(mapping_keys[1]),\\n ref='{}/description'.format(ref)))\\n\\n # Register classes and embeds and\\n # check that there are no duplicate class or embed names.\\n name_set, name_errs = _validate_names(mapping=mapping, ref=ref)\\n errors.extend(name_errs)\\n\\n # Validate class fields except properties\\n if 'classes' in mapping:\\n for i, cls_mapping in enumerate(mapping['classes']):\\n errors.extend(\\n _validate_class(\\n mapping=cls_mapping, ref='{}/classes/{}'.format(ref, i)))\\n\\n # Validate properties of the classes and embeds\\n types = _NONCOMPOSITE_TYPE_SET.copy()\\n types.update(name_set)\\n\\n # Check that the graph properties are valid\\n errors.extend(_validate_properties(mapping=mapping, ref=ref, types=types))\\n\\n # Check that the properties of the classes are valid\\n if 'classes' in mapping:\\n for i, cls_mapping in enumerate(mapping['classes']):\\n errors.extend(\\n _validate_properties(\\n mapping=cls_mapping,\\n ref='{}/classes/{}'.format(ref, i),\\n types=types))\\n\\n # Check that the properties of the embeds are valid\\n if 'embeds' in mapping:\\n for i, embed_mapping in enumerate(mapping['embeds']):\\n errors.extend(\\n _validate_properties(\\n mapping=embed_mapping,\\n ref='{}/embeds/{}'.format(ref, i),\\n types=types))\\n\\n # Check that all the plurals of the classes\\n # do not conflict any of the graph properties\\n errors.extend(_validate_plurals(mapping=mapping, ref=ref))\\n\\n return errors\",\n \"def validate_full_schema(self):\\n #self.check_duplicate_labels()\\n for record in self.extension_schema['schema']['@graph']:\\n #self.check_whether_atid_and_label_match(record)\\n if record['@type'] == \\\"rdfs:Class\\\":\\n self.validate_class_schema(record)\\n #self.validate_class_label(record[\\\"@id\\\"])\\n self.validate_validation_field(record)\\n elif record['@type'] == \\\"rdf:Property\\\":\\n self.validate_property_schema(record)\\n #self.validate_property_label(record[\\\"@id\\\"])\\n #self.validate_domainIncludes_field(record[\\\"http://schema.org/domainIncludes\\\"])\\n #self.validate_rangeIncludes_field(record[\\\"http://schema.org/rangeIncludes\\\"])\\n #else:\\n # raise ValueError('wrong @type value found: {}'.format(record))\",\n \"def _handle_with_schema_validation(success_handler, schema_dict):\\n try:\\n schema = Schema(schema_dict)\\n args = schema(request.args.to_dict())\\n except MultipleInvalid as e:\\n return abort(400, 'value at %s failed validation: %s' % (e.path, e.msg))\\n result = success_handler(args)\\n return jsonify(result)\",\n \"def is_schema_valid(self, schema):\\n for k, v in schema.items():\\n if v[0] == \\\"var_len\\\":\\n assert len(v) == 2\\n assert v[1] in TF_VALUE\\n\\n if v[0] == \\\"fixed_len\\\":\\n assert len(v) == 3\\n assert v[1] in TF_VALUE\\n assert isinstance(v[2], list)\",\n \"def get_valid_json_or_abort(schema):\\n\\n json_request = flask.request.get_json(force=True)\\n\\n try:\\n jsonschema.validate(json_request, schema)\\n except jsonschema.ValidationError as e:\\n flask_restful.abort(400, message=e.message)\\n else:\\n return json_request\",\n \"def test_schema_completeness_validation_valid_input(self):\\n for complete_schema in list_of_schema_inputs:\\n validate_json_schema_completeness(complete_schema)\\n\\n assert True\",\n \"def json_attribs_check(func):\\n @wraps(func)\\n def inner_func(jsonStr):\\n gslvtsSchema = {\\\"type\\\":\\\"object\\\",\\n \\\"properties\\\":{\\n \\\"tagID\\\": {\\\"type\\\":\\\"number\\\"}, \\n \\\"UTC\\\": {\\\"type\\\":\\\"string\\\",\\n \\\"format\\\":\\\"date-time\\\"}\\n\\t\\t\\t},\\n\\t\\t\\t\\\"required\\\":[\\\"tagID\\\",\\\"UTC\\\"]\\n }\\n try:\\n jsonGslvts=json.loads(jsonStr)\\n for elem in jsonGslvts:\\n try: \\n validate(elem, gslvtsSchema, format_checker=FormatChecker())\\n except ValidationError, e:\\n print \\\"[-] Invalid json post data. Check it, brah.\\\"\\n print e\\n raise AttributeError \\n except (AttributeError, ValueError):\\n print \\\"[-] IDk what that was, but it wasn't JSON.\\\"\\n raise AttributeError\\n\\n return(func(jsonStr)) \\n return inner_func\",\n \"def test_input_schema(self, data, errors):\\n resp = self.client.post(self.url, json=data)\\n\\n if not errors:\\n assert resp.status_code == 200\\n assert resp.get_json() == {\\n 'status': 'OK',\\n 'message': 'Data published via Upload service',\\n }\\n else:\\n assert resp.status_code == 400\\n assert resp.get_json() == {\\n 'status': 'Error',\\n 'message': 'Input payload validation failed',\\n 'errors': {\\n k: ['Missing data for required field.'] for k in errors\\n },\\n }\",\n \"def validate_input(self, deposition, draft_id=None):\\n v = APIValidator()\\n draft_id = draft_id or deposition.get_default_draft_id()\\n metadata_schema = deposition.type.api_metadata_schema(draft_id)\\n\\n if metadata_schema:\\n schema = self.input_schema.copy()\\n schema['metadata'] = metadata_schema\\n else:\\n schema = self.input_schema\\n\\n # Either conform to dictionary schema or dictionary is empty\\n if not v.validate(request.json, schema) and \\\\\\n request.json:\\n abort(\\n 400,\\n message=\\\"Bad request\\\",\\n status=400,\\n errors=filter_validation_errors(v.errors),\\n )\",\n \"def test_validate_invalid_resume(self):\\n # DEV: `validate` will raise an exception if it could not validate\\n with self.assertRaises(jsonschema.ValidationError):\\n resumeschema.validate(self.invalid_resume)\",\n \"def validate(scheme, data):\\n return validate_common(scheme, data)\",\n \"def validate_index(self):\\n schema_path = pkg_resources.resource_filename(\\n \\\"FLIR.conservator\\\", \\\"index_schema.json\\\"\\n )\\n with open(schema_path) as o:\\n schema = json.load(o)\\n\\n try:\\n with open(self.index_path) as index:\\n index_data = json.load(index)\\n jsonschema.validate(index_data, schema)\\n return True\\n except jsonschema.exceptions.ValidationError as e:\\n logger.error(e.message)\\n logger.debug(e)\\n return False\",\n \"def test_validation_error_json():\\n error = ValidationError(\\n type=\\\"Syntax Error\\\",\\n data={\\\"data\\\": [1, 2, 3]},\\n )\\n\\n assert ValidationError(**json.loads(error.json())) == error\",\n \"def validate(request, schema, variable_decode=True,\\n variable_decode_dict_char=\\\".\\\", variable_decode_list_char=\\\"-\\\",\\n context=None, data=None):\\n\\n if not data:\\n try:\\n data = request.json_body\\n except ValueError:\\n data = request.params\\n\\n if variable_decode is True:\\n data = formencode.variabledecode.variable_decode(data,\\n dict_char=variable_decode_dict_char,\\n list_char=variable_decode_list_char)\\n\\n state = Dummyobj()\\n state.request = request\\n state.context = context\\n\\n schema = inspect.isclass(schema) and schema() or schema\\n\\n return schema.to_python(data, state=state)\",\n \"def test_schema_valid(path, name, data):\\n schemas = metaschemas()\\n if name in ('release-schema.json', 'release-package-schema.json'):\\n metaschema = schemas['release_package_metaschema']\\n elif name == 'record-package-schema.json':\\n metaschema = schemas['record_package_metaschema']\\n elif name in ('project-schema.json', 'project-package-schema.json'):\\n metaschema = schemas['project_package_metaschema']\\n else:\\n metaschema = schemas['metaschema']\\n\\n validate_json_schema(path, name, data, metaschema)\",\n \"def validate(self, data):\\n if data[\\\"start_time_period\\\"] > data[\\\"end_time_period\\\"]:\\n raise serializers.ValidationError(\\\"End time can not be before start time\\\")\\n elif (timezone.now() - data[\\\"end_time_period\\\"]) > timedelta(days=1):\\n raise serializers.ValidationError(\\\"Weather can not be over 24 hours old\\\")\\n elif data[\\\"end_time_period\\\"] > timezone.now():\\n raise serializers.ValidationError(\\\"End time can not be in the future\\\")\\n elif (data[\\\"end_time_period\\\"] - data[\\\"start_time_period\\\"]) >= timedelta(days=1):\\n raise serializers.ValidationError(\\\"Only supports 1 day time frame for weather\\\")\\n return data\",\n \"def test_validate_business_schema():\\n data = {\\n 'business': {\\n 'cacheId': 1,\\n 'foundingDate': '2007-04-08T00:00:00+00:00',\\n 'identifier': 'CP1234567',\\n 'lastLedgerTimestamp': '2019-04-15T20:05:49.068272+00:00',\\n 'lastPreBobFilingTimestamp': '2019-04-15T20:05:49.068272+00:00',\\n 'legalName': 'legal name - CP1234567'\\n },\\n }\\n\\n is_valid, _ = validate(data, 'business', validate_schema=True)\\n\\n assert is_valid\",\n \"def validate_json(func):\\n\\n # get the function name because we're going to\\n # see if we need SCHEMA_POST, SCHEMA_GET, etc.\\n function_name = func.__name__.upper()\\n\\n def wrapped_func(self, *args, **kwargs):\\n respective_schema = getattr(self, 'SCHEMA_' + function_name)\\n json_request = get_valid_json_or_abort(respective_schema)\\n return func(self, json_request, *args, **kwargs)\\n\\n return wrapped_func\",\n \"def validate(self):\\n self.valid = True\\n\\n if self._value is None and self._strict:\\n self.valid = False\\n raise self.MissingFieldData\\n\\n elif self._value is not None:\\n self._type_specific_validation()\",\n \"def test_encode_errors(self):\\n if self._cls == 'MetaschemaType':\\n if self._invalid_validate:\\n self.assert_raises(NotImplementedError, self.import_cls.encode,\\n self._invalid_validate[0], self.typedef)\\n else:\\n if self._invalid_validate:\\n self.assert_raises((ValueError,\\n jsonschema.exceptions.ValidationError),\\n self.import_cls.encode,\\n self._invalid_validate[0], self.typedef)\",\n \"def parse_json_or_fail(message, schema):\\n try:\\n body = tornado.escape.json_decode(message)\\n except ValueError as e:\\n raise tornado.web.HTTPError(400, reason=str(e))\\n\\n try:\\n jsonschema.validate(body, schema)\\n except jsonschema.exceptions.ValidationError as e:\\n raise tornado.web.HTTPError(400, reason=e.message)\\n\\n return body\",\n \"def validate(self, fqn, data, errors):\\n\\t\\terrors.append(\\\"{}: validate() must be implemented for SchemaBase derived classes.\\\".format(self.__class__.__name__))\\n\\t\\treturn False\",\n \"def _validate(self):\\n fields, schema = self.__dict__, self._def.default\\n extra_fields = fields.viewkeys() - schema.viewkeys()\\n if len(extra_fields) > 0:\\n raise AttributeError('Fields found that are not in the schema: %r' % (list(extra_fields)))\\n for key in fields.iterkeys():\\n if type(fields[key]) is not type(schema[key]):\\n raise AttributeError('Invalid %s for field \\\"%s\\\", should be %s' %\\n (type(fields[key]), key, type(schema[key])))\",\n \"def _validate_data(self, vms, fw_rules):\\n self._validate_vms(vms)\\n self._validate_fw_rules(fw_rules)\\n self._validated = True\",\n \"def validate_json(sub_domain, end_point_pattern, method, json_payload):\\n if sub_domain not in REGISTER_INFO:\\n return {\\\"errors\\\": ['invalid sub-domain']}\\n # Get RAML resource\\n raml = REGISTER_INFO[sub_domain][\\\"raml\\\"]\\n raml_end_point = end_point_pattern.replace('<', '{').replace('>', '}')\\n raml_resource = None\\n for resource in raml.resources:\\n if resource.path == raml_end_point and resource.method.lower() == method.lower():\\n raml_resource = resource\\n break\\n if not raml_resource:\\n return {\\\"errors\\\": ['cannot find RAML resource definition']}\\n raml_schema = None\\n # Get schema name from RAML resource\\n if raml_resource.body:\\n for body in raml_resource.body:\\n if body.mime_type == \\\"application/json\\\":\\n schema_name = body.schema\\n for schema in raml.schemas:\\n if schema_name in schema:\\n raml_schema = schema[schema_name]\\n break\\n break\\n if not raml_schema:\\n return {\\\"errors\\\": ['cannot find schema in RAML resource definition']}\\n # Load schema and validate against it\\n try:\\n validator = jsonschema.Draft4Validator(raml_schema, resolver=RELATIVE_RESOLVER)\\n except jsonschema.SchemaError:\\n return {\\\"errors\\\": ['invalid json schema']}\\n errors = sorted(validator.iter_errors(json_payload), key=lambda e: e.path)\\n error_return = []\\n for error in errors:\\n error_return.append(\\\"{}, {}\\\".format(str(list(error.schema_path)), error.message))\\n for suberror in sorted(error.context, key=lambda e: e.schema_path):\\n error_return.append(\\\"{}, {}\\\".format(str(list(suberror.schema_path)), suberror.message))\\n return {\\\"errors\\\": error_return}\",\n \"def validate_config(\\n json_schema: JsonDict, config: Any, config_path: StrSequence\\n) -> None:\\n try:\\n jsonschema.validate(config, json_schema)\\n except jsonschema.ValidationError as e:\\n raise json_error_to_config_error(e, config_path)\",\n \"def validate(instance, schema, cls=None, *args, **kwargs):\\r\\n if cls is None:\\r\\n cls = validator_for(schema)\\r\\n cls.check_schema(schema)\\r\\n cls(schema, *args, **kwargs).validate(instance)\",\n \"def _validate_json(self):\\n # Do we find valid json?\\n try:\\n with open(self.batch_json_path, \\\"rb\\\") as fd:\\n batch_json = json.loads(fd.read())\\n\\n except Exception as err:\\n raise\\n self.message(\\n \\\"[-] Error reading JSON batch file '%s' : '%s'\\\" %\\n (self.batch_json_path, err))\\n return False\\n\\n # Does the json represent a dictionary of the expected form?\\n if not isinstance(batch_json, types.DictionaryType):\\n self.message(\\n \\\"[-] JSON batch file '%s' deserialises to unexpected object type '%s'\\\" %\\n (self.batch_json_path, type(batch_json)))\\n return False\\n\\n # If it is a dictionary does it have the expected characteristics?\\n for endpoint, sys_info in batch_json.items():\\n\\n # Endpoint should be a hostname, IP or some other string\\n # identifier, difficult to validate much beyond 'string'\\n if type(endpoint) not in [types.StringType, types.UnicodeType]:\\n self.message(\\n \\\"[-] Element within JSON batch file '%s' conatins unexpected object type for an endpoint element '%s'. %s : %s\\\" %\\n (self.batch_json_path, type(endpoint), endpoint, sys_info))\\n return False\\n\\n # Does the sys_info dict contain the expected keys?\\n if set(sys_info.keys()).symmetric_difference(\\n set(self.json_batch_template)):\\n self.message(\\n \\\"[-] Unexpected sys_info structure within JSON batch file %s, expected keys '%s' %s : %s\\\" %\\n (self.batch_json_path, self.json_batch_template, endpoint, sys_info))\\n return False\\n\\n # Create a psuedononymised hash of the uuid using MAC addr as salt\\n mac_repr = \\\"0x\\\" + sys_info[\\\"mac_addr\\\"].lower().replace(\\\":\\\", \\\"\\\")\\n sys_info[\\\"hashed_uuid\\\"] = hashlib.sha256(\\n mac_repr + sys_info[\\\"sys_uuid\\\"]).hexdigest()\\n\\n # Remove both the real sys_uuid and the mac_addr from the structure so they do not get submitted to the API\\n # and remain confidential to the submitter\\n del sys_info[\\\"sys_uuid\\\"]\\n del sys_info[\\\"mac_addr\\\"]\\n\\n # Set the read in json structure as the structure of system data to\\n # walk and send to the API\\n self.endpoints_to_check = batch_json\\n\\n self.message(\\\"[+] Batch JSON file validated\\\")\\n return True\",\n \"def validate(self, data):\\n try:\\n employee_rank = data['rank']\\n except KeyError:\\n employee_rank = 0\\n\\n try:\\n supervisor_rank = data['supervisor'].rank\\n except (AttributeError, KeyError):\\n if employee_rank >= 0:\\n return data\\n else:\\n raise serializers.ValidationError('Supervisor must have a rank')\\n\\n if employee_rank > supervisor_rank:\\n raise serializers.ValidationError('Supervisor must have a higher rank than the Employee')\\n return data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7925582","0.78330433","0.7702376","0.7666036","0.7600036","0.75039744","0.75000393","0.74321485","0.73822933","0.73632777","0.7302417","0.72996646","0.7248956","0.71885204","0.718743","0.7182984","0.69556284","0.6946508","0.69202065","0.6914744","0.6913997","0.6910613","0.6892817","0.6866488","0.6859395","0.68378145","0.6835319","0.6810065","0.6810065","0.6770942","0.6770414","0.6756532","0.6689595","0.6601698","0.65896475","0.65882295","0.6578094","0.6568812","0.6565888","0.653349","0.65034866","0.64950615","0.647298","0.64423203","0.6410456","0.6392368","0.6388402","0.63870996","0.63785976","0.63761175","0.6375627","0.6369548","0.63601154","0.63517123","0.6348413","0.63454986","0.6325446","0.6324929","0.6319054","0.63138837","0.6313755","0.6310969","0.62572026","0.6255753","0.6234075","0.6225905","0.6211293","0.6203912","0.62035215","0.6201354","0.6196464","0.6189285","0.61674726","0.6167134","0.6142796","0.61309826","0.6115044","0.6099664","0.6088083","0.6081709","0.6074435","0.607352","0.6071154","0.6068628","0.6067409","0.60669315","0.60635287","0.6051935","0.6051119","0.60222846","0.60154015","0.60152125","0.5985942","0.59824795","0.5982028","0.5970247","0.5967884","0.5966777","0.5964504","0.59560305"],"string":"[\n \"0.7925582\",\n \"0.78330433\",\n \"0.7702376\",\n \"0.7666036\",\n \"0.7600036\",\n \"0.75039744\",\n \"0.75000393\",\n \"0.74321485\",\n \"0.73822933\",\n \"0.73632777\",\n \"0.7302417\",\n \"0.72996646\",\n \"0.7248956\",\n \"0.71885204\",\n \"0.718743\",\n \"0.7182984\",\n \"0.69556284\",\n \"0.6946508\",\n \"0.69202065\",\n \"0.6914744\",\n \"0.6913997\",\n \"0.6910613\",\n \"0.6892817\",\n \"0.6866488\",\n \"0.6859395\",\n \"0.68378145\",\n \"0.6835319\",\n \"0.6810065\",\n \"0.6810065\",\n \"0.6770942\",\n \"0.6770414\",\n \"0.6756532\",\n \"0.6689595\",\n \"0.6601698\",\n \"0.65896475\",\n \"0.65882295\",\n \"0.6578094\",\n \"0.6568812\",\n \"0.6565888\",\n \"0.653349\",\n \"0.65034866\",\n \"0.64950615\",\n \"0.647298\",\n \"0.64423203\",\n \"0.6410456\",\n \"0.6392368\",\n \"0.6388402\",\n \"0.63870996\",\n \"0.63785976\",\n \"0.63761175\",\n \"0.6375627\",\n \"0.6369548\",\n \"0.63601154\",\n \"0.63517123\",\n \"0.6348413\",\n \"0.63454986\",\n \"0.6325446\",\n \"0.6324929\",\n \"0.6319054\",\n \"0.63138837\",\n \"0.6313755\",\n \"0.6310969\",\n \"0.62572026\",\n \"0.6255753\",\n \"0.6234075\",\n \"0.6225905\",\n \"0.6211293\",\n \"0.6203912\",\n \"0.62035215\",\n \"0.6201354\",\n \"0.6196464\",\n \"0.6189285\",\n \"0.61674726\",\n \"0.6167134\",\n \"0.6142796\",\n \"0.61309826\",\n \"0.6115044\",\n \"0.6099664\",\n \"0.6088083\",\n \"0.6081709\",\n \"0.6074435\",\n \"0.607352\",\n \"0.6071154\",\n \"0.6068628\",\n \"0.6067409\",\n \"0.60669315\",\n \"0.60635287\",\n \"0.6051935\",\n \"0.6051119\",\n \"0.60222846\",\n \"0.60154015\",\n \"0.60152125\",\n \"0.5985942\",\n \"0.59824795\",\n \"0.5982028\",\n \"0.5970247\",\n \"0.5967884\",\n \"0.5966777\",\n \"0.5964504\",\n \"0.59560305\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76444364"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":4494,"cells":{"query":{"kind":"string","value":"Validate that the installed version is consistent with an optional version specification in the twine file."},"document":{"kind":"string","value":"def _validate_twine_version(self, twine_file_twined_version):\n installed_twined_version = pkg_resources.get_distribution(\"twined\").version\n logger.debug(\n \"Twine versions... %s installed, %s specified in twine\", installed_twined_version, twine_file_twined_version\n )\n if (twine_file_twined_version is not None) and (installed_twined_version != twine_file_twined_version):\n raise exceptions.TwineVersionConflict(\n f\"Twined library version conflict. Twine file requires {twine_file_twined_version} but you have {installed_twined_version} installed\"\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def is_valid_version(self):\n pass","def validate_configurator_version():\n if settings.CONFIGURATOR_MODULE == \"bootmachine.contrib.configurators.salt\":\n pkgver = settings.SALT_AUR_PKGVER\n pkgrel = settings.SALT_AUR_PKGREL\n response = urllib2.urlopen(\"https://aur.archlinux.org/packages/sa/salt/PKGBUILD\")\n for line in response:\n if line.startswith(\"pkgver=\") and not pkgver in line:\n abort(\"The requested Salt 'pkgrel={0}' in the AUR was updated to '{1}'.\".format(\n pkgver, line.strip()))\n if line.startswith(\"pkgrel=\") and not pkgrel in line:\n abort(\"The requested Salt 'pkgrel={0}' in the AUR was updated to '{1}'.\".format(\n pkgrel, line.strip()))","def check_version(ctx, _, value):\n if not value or ctx.resilient_parsing:\n return\n\n click.echo(f\"geocube v{importlib.metadata.version('geocube')}\")\n\n ctx.exit()","def test_schema_version(self):\n\n self.validator.adata.uns[\"schema_version\"] = \"1.0.0\"\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors,\n [\n \"ERROR: Schema version '1.0.0' is not supported. Current supported versions: '['2.0.0']'. \"\n \"Validation cannot be performed.\"\n ],\n )","def validate_project_version(config: Dict[str, Any]) -> None:\n spacy_version = config.get(\"spacy_version\", None)\n if spacy_version and not is_compatible_version(about.__version__, spacy_version):\n err = (\n f\"The {PROJECT_FILE} specifies a spaCy version range ({spacy_version}) \"\n f\"that's not compatible with the version of spaCy you're running \"\n f\"({about.__version__}). You can edit version requirement in the \"\n f\"{PROJECT_FILE} to load it, but the project may not run as expected.\"\n )\n msg.fail(err, exits=1)","def test_valid_hh_version():\n # TODO: Basically only enforcing correct main segment, since not using `re.fullmatch`\n # TODO: Probably want `re.fullmatch` here - Currently ignoring any potentially invalid suffix\n version_pattern = r\"^[0-9]+\\.[0-9]+\\.[0-9]+(|a[0-9]|b[0-9]|rc[0-9])\"\n res = re.match(version_pattern, hh.__version__)\n assert res is not None","def test_versionString(self):\n self.assertIn(\"%d.%d.%d\" % nevow.__version_info__, nevow.__version__)","def test_version():\n with open(\"pyproject.toml\") as f:\n tomllines = f.read().splitlines()\n tomlversion = set([l for l in tomllines if \"version =\" in l])\n initversion = set([f'version = \"{mei2volpiano.__version__}\"'])\n # set is there to catch any duplicate/additional entries\n assert initversion == tomlversion","def validate_required_python_version_running(minimal_required_version: str) -> None:\n try:\n parts = minimal_required_version.split(\".\")\n min_py_version = 1000000*int(parts[0]) + 1000*(int(parts[1]) if len(parts) > 1 else 0) + (int(parts[2]) if len(parts) > 2 else 0)\n running_py_version = 1000000*sys.version_info.major + 1000*sys.version_info.minor + sys.version_info.micro\n if running_py_version < min_py_version:\n raise RuntimeError(\"\")\n except:\n raise RuntimeError(f\"Kqlmagic requires python >= {Constants.MINIMAL_PYTHON_VERSION_REQUIRED}, you use python {sys.version}\")","def check_version(self, node):\n assert \"version\" in node, \"Version node does not contain attribute 'version'\"\n assert len(node[\"version\"]) >= 1, \"Expecting at least one 'version' value\"\n # TODO: add more thorough checks","def validate_backend_version(self):\n pass","def validate_version(version):\n matched = VERSION_REGEX.match(version)\n if matched is None:\n print_stderr(\"Version '{0}' does not match version regex\".format(version))\n return\n\n # Format is syntactically valid\n version_dict = matched.groupdict()\n\n # Check dependents\n dependencies = [(\"special_sep\", \"special\"), (\"special\", \"special_sep\"), (\"index_sep\", \"index\"), (\"index\", \"index_sep\"), (\"index\", \"special\"), (\"special\", \"index\")]\n for dependent, dependency in dependencies:\n if version_dict[dependent] and not version_dict[dependency]:\n print_stderr(\"Version '{0}' is invalid: '{1}' is defined but not '{2}'\".format(version, dependent, dependency))\n return None\n\n # Remove noise\n for noise in [\"special_sep\", \"index_sep\"]:\n del version_dict[noise]\n\n return version_dict","def test_pynast_suported_version(self):\r\n min_acceptable_version = (1, 2)\r\n max_acceptable_version = (1, 2, 2)\r\n try:\r\n from pynast import __version__ as pynast_lib_version\r\n version = pynast_lib_version.split('.')\r\n if version[-1][-4:] == '-dev':\r\n version[-1] = version[-1][:-4]\r\n version = tuple(map(int, version))\r\n pass_test = (version >= min_acceptable_version and\r\n version <= max_acceptable_version)\r\n version_string = str(pynast_lib_version)\r\n except ImportError:\r\n pass_test = False\r\n version_string = \"Not installed\"\r\n\r\n min_version_str = '.'.join(map(str, min_acceptable_version))\r\n max_version_str = '.'.join(map(str, max_acceptable_version))\r\n error_msg = (\"Unsupported pynast version. Must be >= %s and <= %s, \"\r\n \"but running %s.\" % (min_version_str, max_version_str,\r\n version_string))\r\n self.assertTrue(pass_test, error_msg)","def package_version_check(args, parser):\n if (args.build or args.check) and args.package_version:\n parser.error('--package-version works only with --create')","def test_version_missing(self):\r\n self.assertIsNone(self._version_test(self.no_version))","def check_version(ctx, builder, version_function, *,\n requires_version=None,\n requires_at_least_version=None,\n requires_at_most_version=None):\n if any(v is not None for v in (\n requires_version,\n requires_at_least_version,\n requires_at_most_version)):\n ctx.logger.check('checking %s version' % builder)\n\n version_str = version_function()\n\n # Convert the version into a tuple\n version = []\n for i in version_str.split('.'):\n try:\n version.append(int(i))\n except ValueError:\n # The subversion isn't a number, so just convert it to a\n # string.\n version.append(i)\n version = tuple(version)\n\n if requires_version is not None and requires_version != version:\n msg = 'version %s required; found %s' % (\n '.'.join(str(i) for i in requires_version), version_str)\n\n ctx.logger.failed(msg)\n raise fbuild.ConfigFailed(msg)\n\n if requires_at_least_version is not None and \\\n requires_at_least_version > version:\n msg = 'at least version %s required; found %s' % (\n '.'.join(str(i) for i in requires_at_least_version),\n version_str)\n\n ctx.logger.failed(msg)\n raise fbuild.ConfigFailed(msg)\n\n if requires_at_most_version is not None and \\\n requires_at_most_version < version:\n msg = 'at most version %s required; found %s' % (\n '.'.join(str(i) for i in requires_at_most_version),\n version_str)\n\n ctx.logger.failed(msg)\n raise fbuild.ConfigFailed(msg)\n\n ctx.logger.passed(version_str)","def test_version(self):\n version_instance = get_version('kolibri', __file__)\n self.assertIn(version_instance.major_version, kolibri.__version__)","def test_version():\n versions = ((2, 7, 16), (3, 5, 7), (3, 6, 8), (3, 7, 3))\n assert sys.version_info[:3] in versions","def test_version(self) -> None:\n with open(\"pyproject.toml\") as f:\n for line in f:\n if \"version\" in line:\n version = line.split()[-1].replace('\"', \"\")\n break\n self.assertEqual(__version__, version)","def check_from_version(version: str) -> str:\n version_int = [int(v) for v in version.split(\".\")]\n if version_int[0] not in PipetteModelMajorVersion:\n raise ValueError(f\"Major version {version_int[0]} is not supported.\")\n if version_int[1] not in PipetteModelMinorVersion:\n raise ValueError(f\"Minor version {version_int[1]} is not supported.\")\n return version","def is_version_valid(version):\n return _compiled_version_regex.match(version) is not None","def _checkUpdateNeeded(self):\n try:\n currentVersionLine = str(subprocess.run(['pacman', '-Q', '-i', self._name],\n stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=True).stdout)\n currentVersion = re.sub(r'.*Version\\s*: ([\\d|\\.]*)-.*', r'\\1', currentVersionLine).split('.')\n newVersion = self._version.split('.')\n for i in range(0, min(len(currentVersion), len(newVersion))):\n if currentVersion[i].isdigit():\n # TODO: test if new version is only digits too, two of them should be the same anyway\n if int(newVersion[i]) > int(currentVersion[i]):\n return True\n if int(newVersion[i]) < int(currentVersion[i]):\n return False\n return len(newVersion) > len(currentVersion)\n except subprocess.CalledProcessError:\n # Package not found: to be installed then\n return True","def check_version_is_supported(name, version, min_version, help=''):\n if (pkg_resources.parse_version(version) <\n pkg_resources.parse_version(min_version)):\n # Version is too old.\n print('ERROR: Unsupported %s version: %s (minimum %s).%s' %\n (name, version, min_version, (' %s' % help) if help else ''),\n file=sys.stderr)\n exit(1)","def check_version_2(dataset):\n\n if float(dataset.get('version')) >= 2.0 \\\n if dataset.get('version') else False:\n return True\n else:\n return False","def check_version():\n reset_flag = False\n try:\n data = du.read_yml(du.DEFAULT)\n if (\n data[\"version\"].split(\".\")[0] != __version__.split(\".\")[0]\n ): # If Version if different from \"1.x.y\" remove data:\n reset_flag = True\n except (KeyError, FileNotFoundError, TypeError):\n reset_flag = True\n\n if reset_flag:\n print(\"Your configuration file version is older than 1.0.0\")\n print(\n \"Your .Experiment file will be removed, please run daf.init to generate an up-to-date file\"\n )\n if os.path.isfile(du.DEFAULT):\n os.remove(du.DEFAULT)\n sys.exit(0)","def is_valid_version(self) -> bool:\n return self._is_valid_version()","def check_all():\n for package, version in required_versions.items():\n try:\n module = importlib.import_module(package)\n except ImportError:\n return\n else:\n if StrictVersion(version) > StrictVersion(module.__version__):\n raise RuntimeError(\"Your version of %s is too old - it must be at least %s\" % (\n package,\n version,\n ))","def check_version_part(self, node, ecosystem, package, version):\n version_node = node[\"version\"]\n # check the ecosystem, version, and name attributes that are required for a version\n self.check_pecosystem(version_node)\n self.check_pname(version_node)\n self.check_version(version_node)\n\n # compare with expected values\n e = version_node[\"pecosystem\"][0]\n p = version_node[\"pname\"][0]\n v = version_node[\"version\"][0]\n self.compare_ecosystems(e, ecosystem)\n self.compare_packages(p, package)\n self.compare_versions(v, version)","def check_py_version(self, cur_version):\n\n # convert cur_version to string, in case of erroneous type being passed\n cur_version = str(cur_version)\n\n acceptable_python_versions_regex = r\"(^(2\\.[6-9])(\\.?\\d{1,2})?$)|(^(3\\.[3-9])(\\.?\\d{1,2})?$)\"\n pyversions_regex_compiled = re.compile(acceptable_python_versions_regex)\n pyversions_match = pyversions_regex_compiled.match(cur_version)\n\n # If match is found, return True. If no match, return False\n if pyversions_match:\n return True\n else:\n return False","def test_versioning_unknown_version(workflow_runner):\n with pytest.raises(WDL.Error.SyntaxError):\n workflow_runner(\"test_versioning_unknown_version.wdl\")","def check_openhpiver(reqver_text):\n\treturn check_pkgcfg_ver(reqver_text, 'openhpi')","def check_cal_format_version(version: Optional[Version] = None, current_version: Version = _CAL_FORMAT_VERSION):\n # No version means, the old 1.0 format is used that does not provide a version string\n if not version:\n version = Version(\"1.0.0\")\n if isinstance(version, str):\n version = Version(version)\n\n if version == current_version:\n return\n if version > current_version:\n raise ValueError(\"The provided version, is larger than the currently supported version.\")\n if version < current_version:\n raise ValueError(\n \"The provided calibration format is no longer supported. \"\n \"Check `imucal.legacy` if conversion helper exist.\"\n )","def checkVersion(self, clientName, edamVersionMajor, edamVersionMinor):\r\n pass","def test_patch_hyperflex_software_version_policy(self):\n pass","def test_lowest_version(self):\n self.assertEqual({\"python-xyz\": \"1\",\n \"python-foo\": \"3.1\"},\n pr.sanitize_requirements(\n [\"xyz>=1,>=2\", \"foo>=4,>=3.1\"]))","def python_version_check():\n min_version_list = PYTHON_MIN_VERSION.split(\".\")\n # Truncate if the list is more the 4 items\n if len(min_version_list) > 4:\n min_version_list = min_version_list[:4]\n # Fill if the list is less then 4 items\n if len(min_version_list) == 1:\n min_version_list.append(\"0\")\n if len(min_version_list) == 2:\n min_version_list.append(\"0\")\n if len(min_version_list) == 3:\n min_version_list.append(\"f0\")\n # Calculate the minimum version and an integer, which, when displayed as\n # hex, is easily recognised as the version. E.g. 0x30502f0 is 3.5.2\n min_version_value = 0\n for index, item in enumerate(min_version_list[::-1]):\n min_version_value = min_version_value + int(item, 16) * 2**(index * 8)\n if debug: print(\"Python Version Minimum:{}, Decimal:{}, Hex:{}\"\n .format(PYTHON_MIN_VERSION, min_version_value,\n hex(min_version_value)))\n # test value and exit if below minimum revision\n if sys.hexversion < min_version_value:\n print(\"Python Version: {}. Required minimum version is: {}. Exiting...\"\n .format(sys.version.split(\" \")[0], PYTHON_MIN_VERSION))\n sys.exit()","def _verify_patchelf() -> None:\n if not find_executable(\"patchelf\"):\n raise ValueError(\"Cannot find required utility `patchelf` in PATH\")\n try:\n version = check_output([\"patchelf\", \"--version\"]).decode(\"utf-8\")\n except CalledProcessError:\n raise ValueError(\"Could not call `patchelf` binary\")\n\n m = re.match(r\"patchelf\\s+(\\d+(.\\d+)?)\", version)\n if m and tuple(int(x) for x in m.group(1).split(\".\")) >= (0, 14):\n return\n raise ValueError(\n f\"patchelf {version} found. auditwheel repair requires \" \"patchelf >= 0.14.\"\n )","def check_versioning(ctx, stmt):\n\n # Don't perform this check for modules that are not OpenConfig\n # or are OpenConfig infrastructure (e.g., extensions)\n if (OCLintFunctions.is_openconfig_validatable_module(stmt.arg) in\n [ModuleType.NONOC, ModuleType.OCINFRA]):\n return\n\n version = None\n for substmt in stmt.substmts:\n # pyang uses a keyword tuple when the element is from\n # an external extension rather than a built-in, check for\n # this before checking the argument. Assumption is made\n # that openconfig-version is unique across all extension\n # modules.\n if (isinstance(substmt.keyword, tuple) and\n substmt.keyword[1] == \"openconfig-version\"):\n version = substmt\n\n if version is None:\n err_add(ctx.errors, stmt.pos, \"OC_MODULE_MISSING_VERSION\",\n stmt.arg)\n return\n\n if not re.match(r\"^[0-9]+\\.[0-9]+\\.[0-9]+$\", version.arg):\n err_add(ctx.errors, stmt.pos, \"OC_INVALID_SEMVER\",\n version.arg)\n\n # Check that there\n match_revision = False\n for revision_stmt in stmt.search(\"revision\"):\n reference_stmt = revision_stmt.search_one(\"reference\")\n if reference_stmt is not None and reference_stmt.arg == version.arg:\n match_revision = True\n\n if match_revision is False:\n err_add(ctx.errors, stmt.pos, \"OC_MISSING_SEMVER_REVISION\",\n version.arg)","def version_match(required, candidate):\n return _discover.version_match(required, candidate)","def solr_version_check(core):\n expected_version = SCHEMA[core].version\n solr_uri = config.CFG.get(\"solr\", \"uri\")\n u = urllib2.urlopen(\"%s/%s/schema/version\" % (solr_uri, core))\n content = loads(u.read())\n seen_version = content[\"version\"]\n if not seen_version == expected_version:\n raise VersionMismatchException(core, expected_version, seen_version)\n logger.debug(\"%s: version %1.1f matches %1.1f\", core, expected_version,\n seen_version)","def testStratisVersion(self):\n version = Manager.Properties.Version.Get(get_object(TOP_OBJECT))\n (major, _, _) = version.split(\".\")\n self.assertEqual(major, \"0\")","def test_required_fields_schema_version(self):\n\n del self.validator.adata.uns[\"schema_version\"]\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors,\n [\n \"ERROR: adata has no schema definition in 'adata.uns'. \"\n \"Validation cannot be performed.\"\n ],\n )","def is_stable_version(version):\n if not isinstance(version, tuple):\n version = version.split('.')\n last_part = version[-1]\n\n if not re.search('[a-zA-Z]', last_part):\n return True\n else:\n return False","def _check_version () -> None:\n py_version_info: typing.Tuple = sys.version_info[:2]\n\n if py_version_info < MIN_PY_VERSION:\n error_msg = \"This version of pytextrank requires Python {} or later ({} detected)\\n\"\n raise RuntimeError(error_msg.format(_versify(MIN_PY_VERSION), _versify(py_version_info)))","def assert_version(version, minimum=VERSION_MINIMUM, maximum=VERSION_MAXIMUM, blacklist=VERSION_BLACKLIST):\n\t# Convert version strings to integer tuples\n\tversion = list(map(int, version.split('-', 1)[0].split('.')))\n\tminimum = list(map(int, minimum.split('-', 1)[0].split('.')))\n\tmaximum = list(map(int, maximum.split('-', 1)[0].split('.')))\n\n\tif minimum > version or version >= maximum:\n\t\traise exceptions.VersionMismatch(version, minimum, maximum)\n\t\n\tfor blacklisted in blacklist:\n\t\tblacklisted = list(map(int, blacklisted.split('-', 1)[0].split('.')))\n\t\tif version == blacklisted:\n\t\t\traise exceptions.VersionMismatch(version, minimum, maximum)","def _check_python_version(self):\n python_exe = tools.which(\"python\")\n if not python_exe:\n msg = (\"Python must be available in PATH \"\n \"in order to build v8\")\n raise ConanInvalidConfiguration(msg)\n # In any case, check its actual version for compatibility\n from six import StringIO # Python 2 and 3 compatible\n version_buf = StringIO()\n cmd_v = \"{} --version\".format(python_exe)\n self.run(cmd_v, output=version_buf)\n p = re.compile(r'Python (\\d+\\.\\d+\\.\\d+)')\n verstr = p.match(version_buf.getvalue().strip()).group(1)\n if verstr.endswith('+'):\n verstr = verstr[:-1]\n version = tools.Version(verstr)\n # >= 2.7.5 & < 3\n py2_min = \"2.7.5\"\n py2_max = \"3.0.0\"\n py3_min = \"3.8.0\"\n if (version >= py2_min) and (version < py2_max):\n msg = (\"Found valid Python 2 required for v8:\"\n \" version={}, path={}\".format(version_buf.getvalue().strip(), python_exe))\n self.output.success(msg)\n elif version >= py3_min:\n msg = (\"Found valid Python 3 required for v8:\"\n \" version={}, path={}\".format(version_buf.getvalue().strip(), python_exe))\n self.output.success(msg)\n else:\n msg = (\"Found Python in path, but with invalid version {}\"\n \" (v8 requires >= {} and < \"\n \"{} or >= {})\".format(verstr, py2_min, py2_max, py3_min))\n raise ConanInvalidConfiguration(msg)","def test_pre_release(scraper, version_parts):\n\n new_version_parts = list(version_parts)\n if len(new_version_parts) > 4:\n new_version_parts[4] = int(new_version_parts[4]) + 1\n elif len(new_version_parts) > 3:\n new_version_parts.append(1)\n else:\n new_version_parts.extend(['a', 1])\n\n assert scraper.is_compatible_with(generate_version(new_version_parts)) is True","def checkIfVersionIsExact(testConfig):\n assert \"name\" in testConfig\n assert \"binary\" in testConfig\n assert \"version\" in testConfig\n \n #Set default version command as \"testConfig[\"name\"] --version\"\n #Otherwise, use testConfig[\"version_command\"]\n if \"version_command\" in testConfig:\n versionCommand = testConfig[\"version_command\"]\n else:\n versionCommand = testConfig[\"binary\"]+r\" --version\"\n \n #Run the version command, grab stdout and stderr\n p = subprocess.Popen(versionCommand.split(), stdout=subprocess.PIPE,stderr=subprocess.PIPE)\n versionOut,versionError = p.communicate()\n versionOut = str(versionOut)+str(versionError)\n \n #Find all instances of something that could be the version number in the output\n installedVersion = re.findall(r\"([0-9.]*[0-9]+)\", versionOut)\n \n #Go through all the matches, if anything starts with our expected version,\n #Set test as pass\n testPass=False\n for version in installedVersion:\n if re.match(testConfig[\"version\"],str(version)) :\n testPass=True\n break\n \n \n assert testPass,\"\\nVersion output was :\"+versionOut+\\\n \"\\nExpected version: \"+testConfig[\"version\"]+\\\n \"\\n Test failed.\"","def _check_version(version):\n # Update cache if needed.\n if _check_version._versions_cache is None:\n log.debug(\"Loading versions cache ...\")\n _check_version._versions_cache = __salt__[\"netbeans.list_versions\"]()\n\n # Convert latest.\n if version is None or version == \"latest\":\n return __salt__[\"netbeans.pick_latest_version\"](\n _check_version._versions_cache\n )\n\n # Check if version is available.\n if version not in _check_version._versions_cache:\n return None\n return version","def test1_version(self):\n lVersion = rdbhdb.__version__.split('.')\n nVersion = need_version.split('.')\n self.assert_(lVersion >= nVersion, rdbhdb.__version__)","def check_version_str(version):\n if not version.startswith('v') and version != 'current':\n version = 'v%s' % version\n return version","def validate_available(parser, options):\n if not options.available:\n return\n\n if not options.manifest_id:\n parser.error(\"When specifying --available, --manifest-id is also required\")","def test_arg_version(run_nait) -> None: # type: ignore\n expected = nanaimo.version.__version__\n assert run_nait(['--version']).stdout.decode('utf-8').startswith(expected)","def valid_version(self, new_version):\n if not re.match(r\"\\d+\\.\\d+\\.\\d+\", new_version):\n return False\n\n x1, y1, z1 = [int(i) for i in self.current_version().split(\".\")]\n x2, y2, z2 = [int(i) for i in new_version.split(\".\")]\n\n if x2 < x1:\n return False\n\n if x2 == x1 and y2 < y1:\n return False\n\n if x2 == x1 and y2 == y1 and z2 <= z1:\n return False\n\n return True","def _check_required(self):\n if self.data['history_file'] is None:\n return\n required = self.data.get('required_changelog_text')\n if not required:\n return\n if isinstance(required, six.string_types):\n required = [required]\n history_last_release = self.data['history_last_release']\n for text in required:\n if text in history_last_release:\n # Found it, all is fine.\n return\n pretty_required = '\"{}\"'.format('\", \"'.join(required))\n if not utils.ask(\n \"WARNING: Changelog should contain at least one of \"\n \"these required strings: {}. Are you sure you \"\n \"want to release?\".format(pretty_required),\n default=False):\n sys.exit(1)","def test_above_24_latest_version(self):\n self.data['version'] = ''\n self.data['appVersion'] = '28.0'\n\n up = self.get(self.data)\n rdf = up.get_rdf()\n assert rdf.find('20202020.01') > -1","def require_version(version):\n def check_require_version(f):\n version_elements = version.split('.')\n try:\n compare = tuple([int(v) for v in version_elements])\n except ValueError:\n raise ValueError('%s is not a correct version : should be X.Y[.Z].' % version)\n current = sys.version_info[:3]\n if current < compare:\n def new_f(self, *args, **kwargs):\n self.skipTest('Need at least %s version of python. Current version is %s.' % (version, '.'.join([str(element) for element in current])))\n new_f.__name__ = f.__name__\n return new_f\n else:\n return f\n return check_require_version","def _sanityCheckProtocolVersions(other):\n if other.minVersion > other.maxVersion:\n raise ValueError(\"Versions set incorrectly\")\n if other.minVersion not in KNOWN_VERSIONS:\n raise ValueError(\"minVersion set incorrectly\")\n if other.maxVersion not in KNOWN_VERSIONS:\n raise ValueError(\"maxVersion set incorrectly\")\n\n if other.maxVersion < (3, 4):\n other.versions = [i for i in other.versions if i < (3, 4)]","def test_undefined_semver(self):\n v1 = versions.Version(version='1.2.3', name='foo')\n expected = None\n\n self.assertEqual(v1.build, expected)","def test_version(self, parse_input):\n bb = parse_input(\"name testname\\nversion 1.0\")\n assert bb.version == \"1.0\"\n\n bb = parse_input(\"name testname\\nversion 1.12\")\n assert bb.version == \"1.12\"","def test_parse_invalid_version(self):\n version = VersionNumberScaleMeasurement.parse_version(\"This is not a version number\")\n self.assertEqual(Version(\"0\"), version)","def check_schema_version(context, version):\n data = context.response.json()\n check_and_get_attribute(data, version)","def _check_server_version(self, server_version: str) -> None:\n cur_version = parse_version(server_version)\n min_version = parse_version(MIN_SERVER_VERSION)\n if cur_version < min_version:\n raise InvalidServerVersion\n if cur_version != min_version:\n self._logger.warning(\n \"Connected to a Zwave JS Server with an untested version, \\\n you may run into compatibility issues!\"\n )","def checkIfMinimumVersionIsMet(testConfig):\n assert \"name\" in testConfig\n assert \"binary\" in testConfig\n assert \"minimum_version\" in testConfig\n \n #Set default version command as \"testConfig[\"name\"] --version\"\n #Otherwise, use testConfig[\"version_command\"]\n if \"version_command\" in testConfig:\n versionCommand = testConfig[\"version_command\"]\n else:\n versionCommand = testConfig[\"binary\"]+r\" --version\"\n \n #Run the version command, grab stdout and stderr\n p = subprocess.Popen(versionCommand.split(), stdout=subprocess.PIPE,stderr=subprocess.PIPE)\n versionOut,versionError = p.communicate()\n versionOut = str(versionOut)+str(versionError)\n \n #Find all instances of something that could be the version number in the output\n installedVersion = re.findall(r\"([0-9]+\\.)+[0-9]+\", versionOut)\n \n #Go through all the matches, if anything starts with our expected version,\n #Set test as pass\n testPass=False\n for version in installedVersion:\n if LooseVersion(str(version)) >= LooseVersion(testConfig[\"minimum_version\"]):\n testPass=True\n break\n \n assert testPass,\"\\nVersion output was :\"+versionOut+\\\n \"\\nExpected minimum version: \"+testConfig[\"minimum_version\"]+\\\n \"\\n Test failed.\"","def test_major(scraper, version_parts):\n\n new_version_parts = list(version_parts)\n new_version_parts[0] = int(new_version_parts[0]) + 1\n\n assert scraper.is_compatible_with(generate_version(new_version_parts)) is False","def test_version_exists():\n assert ztm.__version__","def test_minor(scraper, version_parts):\n\n new_version_parts = list(version_parts)\n new_version_parts[1] = int(new_version_parts[1]) + 1\n\n assert scraper.is_compatible_with(generate_version(new_version_parts)) is True","def check_version(min_version: str,\n warning_only: bool = False,\n library: Optional[ModuleType] = None):\n # pylint: disable=import-outside-toplevel\n from .. import __version__\n if library is None:\n version = __version__\n name = 'GluonNLP'\n else:\n version = library.__version__\n name = library.__name__\n from packaging.version import parse\n bad_version = parse(version.replace('.dev', '')) < parse(min_version)\n if bad_version:\n msg = 'Installed {} version {} does not satisfy the ' \\\n 'minimum required version {}'.format(name, version, min_version)\n if warning_only:\n warnings.warn(msg)\n else:\n raise AssertionError(msg)","def check_pythonver(reqver_text):\n\treqver = map(int, reqver_text.split('.'))\n\tpythonver = sys.version_info[:3]\n\treturn check_ver(pythonver, reqver)","def test_versioned_release_schema():\n path = 'versioned-release-validation-schema.json'\n if os.path.exists(path):\n warn_and_assert([path], '{0} is present, run: rm {0}',\n 'Versioned release schema files are present. See warnings below.')","def check_version():\n err = \"PaddlePaddle version 1.6 or higher is required, \" \\\n \"or a suitable develop version is satisfied as well. \\n\" \\\n \"Please make sure the version is good with your code.\" \\\n\n try:\n fluid.require_version('1.6.0')\n except Exception as e:\n logger.error(err)\n sys.exit(1)","def check_python_version(match, current=None):\n if current is None:\n current = list(sys.version_info[:3])\n if not isinstance(match, list):\n match = [match]\n for m in match:\n minimal = False\n if isinstance(m, float):\n m = str(m)\n if m.endswith(\"+\"):\n minimal = True\n m = m[:-1]\n # assert m[0].isdigit()\n # assert m[-1].isdigit()\n m = [int(x) for x in m.split(\".\")]\n current_len = current[: len(m)]\n # print(m, current, current_len)\n if minimal:\n if current_len >= m:\n return True\n else:\n if current_len == m:\n return True\n return False","def test_local_version(self):\n self.assertIsInstance(__version__, float)","def is_version_2_6() -> bool:\n v = get_version()\n if v[1] != \"singularity\" and v[1] != \"singularity-ce\":\n return False\n return v[0][0] == 2 and v[0][1] == 6","def compatible_version(self):\n note_version = self.py_version\n py_version = sys.version_info\n if note_version[0] != py_version[0]:\n return False\n if len(note_version) > 1 and note_version[1] > py_version[1]:\n return False\n return True","def test_versionInfo(self):\n self.assertEqual(\n nevow.__version_info__,\n (nevow.version.major, nevow.version.minor, nevow.version.micro))","def _is_version_uptodate(self):\n logging.info(\"Checking tesseract version\")\n cmd = '%s -v' % (self.binary)\n logging.info(cmd) \n try:\n ret_output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)\n except CalledProcessError:\n # Could not run tesseract\n error(self.msgs['TS_MISSING'])\n\n ver_str = '0.0.0'\n for line in ret_output.splitlines():\n if 'tesseract' in line:\n ver_str = line.split(' ')[1]\n if ver_str.endswith('dev'): # Fix for version strings that end in 'dev'\n ver_str = ver_str[:-3]\n\n # Iterate through the version dots\n ver = [int(x) for x in ver_str.split('.')]\n req = [int(x) for x in self.required.split('.')]\n\n # Aargh, in windows 3.02.02 is reported as version 3.02 \n # SFKM\n if str(os.name) == 'nt':\n req = req[:2]\n\n version_good = False\n for i,num in enumerate(req):\n if len(ver) < i+1:\n # This minor version number is not present in tesseract, so it must be\n # lower than required. (3.02 < 3.02.01)\n break\n if ver[i]==num and len(ver) == i+1 and len(ver)==len(req):\n # 3.02.02 == 3.02.02\n version_good = True\n continue\n if ver[i]>num:\n # 4.0 > 3.02.02\n # 3.03.02 > 3.02.02\n version_good = True\n break\n if ver[i]<num:\n # 3.01.02 < 3.02.02\n break\n \n return version_good, ver_str","def test_invalid_version_fields(self):\n self.assertRaises(ValueError, versions.Version, version='1234', name='foo')","def model_is_valid(self, model: OscalBaseModel) -> bool:\n oscal_version = model.metadata.oscal_version.__root__\n p = re.compile(OSCAL_VERSION_REGEX)\n matched = p.match(oscal_version)\n return matched is not None","def check_package_version(self, node, ecosystem, package, version):\n assert \"package\" in node, \"'package' node is expected\"\n assert \"version\" in node, \"'version' node is expected\"\n self.check_package_part(node, ecosystem, package)\n self.check_version_part(node, ecosystem, package, version)\n # TODO: add more thorough checks","def test_invalid_version_ints(self):\n self.assertRaises(ValueError, versions.Version, version='1a.2', name='foo')","def checkPatchValidity(val):\n\n tag_list = val.split('-')\n if len(tag_list) < 5:\n return False\n\n if tag_list[0] not in os.environ.get('environment'):\n return False\n\n if tag_list[1] not in os.environ.get('platform'):\n return False\n\n if tag_list[2] not in os.environ.get('role'):\n return False \n\n if tag_list[3] not in os.environ.get('urgency'):\n return False \n\n if tag_list[4] not in os.environ.get('order'):\n return False\n\n return True","def _check_package_version(package, min_version):\n # Re-raise with a more informative message when the package is not\n # installed\n try:\n module = import_module(package)\n except ModuleNotFoundError:\n raise ModuleNotFoundError(\"Please install {0} with a version >= \"\n \"{1} in order to install scikit-lr.\"\n .format(package, min_version))\n\n if LooseVersion(module.__version__) < min_version:\n raise ValueError(\"The current version of {0} is {1} installed in {2}.\"\n .format(package, module.__version__, module.__path__))","def test_update_hyperflex_software_version_policy(self):\n pass","def test_version_check_update_available(self):\n output = self.run_command(\"selfupdate --check bennr01:selfupdate_test_future\", exitcode=0)\n self.assertIn(\"Target: bennr01:selfupdate_test_future\", output)\n self.assertNotIn(\"Target: ywangd:master\", output)\n self.assertNotIn(\"Already at latest version\", output)\n self.assertIn(\"New version available\", output)\n self.assertNotIn(\"Error: \", output)","def test_Validator_is_valid_two_arguments(self):\n\n validator = validators.Draft7Validator({})\n with self.assertWarns(DeprecationWarning) as w:\n result = validator.is_valid(\"foo\", {\"type\": \"number\"})\n\n self.assertFalse(result)\n self.assertEqual(w.filename, __file__)\n self.assertTrue(\n str(w.warning).startswith(\n \"Passing a schema to Validator.is_valid is deprecated \",\n ),\n )","def VerifyVersion(root):\r\n global VERSION\r\n global REQUIRED_VERSION\r\n try:\r\n if root.get(\"version\") < REQUIRED_VERSION:\r\n raise XmlVersionError(\"XML Version must be %s or above, we found %s!\" \\\r\n % (REQUIRED_VERSION, root.get(\"version\")))\r\n except KeyError:\r\n raise MalformedXmlError()","def test_VersionOptionalFields():\n # onlyRequiredVersion is a version message that only contains the\n # required versions and all other values set to their default values.\n onlyRequiredVersion = minimumMsgVersion()\n\n onlyRequiredVersionEncoded = baseVersionEncoded()[:-55]\n\n # addrMeVersion is a version message that contains all fields through\n # the AddrMe field.\n addrMe = netaddress.NetAddress(\n ip=\"127.0.0.1\", port=8333, services=wire.SFNodeNetwork, stamp=0,\n )\n addrMeVersion = minimumMsgVersion()\n addrMeVersion.addrMe = addrMe\n\n addrMeVersionEncoded = baseVersionEncoded()[:-29]\n\n # nonceVersion is a version message that contains all fields through\n # the Nonce field.\n nonceVersion = minimumMsgVersion()\n nonceVersion.addrMe = addrMe\n nonceVersion.nonce = 123123 # 0x1e0f3\n nonceVersionEncoded = baseVersionEncoded()[:-21]\n\n # uaVersion is a version message that contains all fields through\n # the UserAgent field.\n uaVersion = minimumMsgVersion()\n uaVersion.addrMe = addrMe\n uaVersion.nonce = 123123\n uaVersion.userAgent = \"/dcrdtest:0.0.1/\"\n uaVersionEncoded = baseVersionEncoded()[:-4]\n\n # lastBlockVersion is a version message that contains all fields\n # through the LastBlock field.\n lastBlockVersion = minimumMsgVersion()\n lastBlockVersion.addrMe = addrMe\n lastBlockVersion.nonce = 123123\n lastBlockVersion.userAgent = \"/dcrdtest:0.0.1/\"\n lastBlockVersion.lastBlock = 234234 # 0x392fa\n lastBlockVersionEncoded = baseVersionEncoded()\n\n tests = [\n (onlyRequiredVersion, onlyRequiredVersionEncoded),\n (addrMeVersion, addrMeVersionEncoded),\n (nonceVersion, nonceVersionEncoded),\n (uaVersion, uaVersionEncoded),\n (lastBlockVersion, lastBlockVersionEncoded),\n ]\n\n for expMsg, buf in tests:\n # Decode the message from wire format.\n msg = msgversion.MsgVersion.btcDecode(buf, wire.ProtocolVersion)\n assert sameMsgVersion(msg, expMsg)","def test_version():\n assert pywren.__version__ is not None","def is_version_sufficient(self, min_version):\n \n try:\n current_version = self.get_software_version()\n return LooseVersion(current_version) >= LooseVersion(min_version)\n except:\n raise","def test_version():\n assert(hasattr(tekel, '__version__'))","def _verify_firmware_version(self):\n firmware_version = self.device.firmware_version\n self.assertTrue(firmware_version)\n self.assertIsInstance(firmware_version, str)","def py_versiontest(c):\n pass","def require_python(version_spec, warn=False, extra_msg=None, prereleases=None):\n valid_specifiers = ('===', '==', '<=', '>=', '!=', '~=', '<', '>')\n for spec in valid_specifiers:\n if version_spec.startswith(spec):\n break\n else:\n if version_spec[0].isdigit():\n version_spec = f'~={version_spec}'\n else:\n raise InvalidSpecifier(\n f\"Invalid version specifier: '{version_spec}'\"\n )\n\n version_constraint = SpecifierSet(version_spec, prereleases=prereleases)\n python_version = sys.version.split()[0]\n if python_version not in version_constraint:\n msg = (\n \"The Python version installed in the environment \"\n f\"(v{python_version}) does not satisfy the constraint \"\n f\"'{version_constraint}'\"\n )\n if extra_msg is not None:\n msg = f\"{msg}.\\n{extra_msg}\"\n\n if warn:\n warnings.warn(msg, category=RuntimeWarning)\n else:\n raise DavosError(msg)","def test_version(self):\n pass","def test_get_version(self):\n pass","def is_valid_version(version):\n return bool(\n is_valid_instance_id(version) or\n is_valid_tag(version) or\n REF_RE.match(version)\n )","def test_patch(scraper, version_parts):\n\n new_version_parts = list(version_parts)\n new_version_parts[2] = int(new_version_parts[2]) + 1\n\n assert scraper.is_compatible_with(generate_version(new_version_parts)) is True","def check_python_version():\n version = sys.version.split()[0]\n if version < \"2.6\" or version >= \"3\":\n raise CuckooStartupError(\"You are running an incompatible version of Python, please use 2.6 or 2.7\")","def test_get_short_version(self):\n pass"],"string":"[\n \"def is_valid_version(self):\\n pass\",\n \"def validate_configurator_version():\\n if settings.CONFIGURATOR_MODULE == \\\"bootmachine.contrib.configurators.salt\\\":\\n pkgver = settings.SALT_AUR_PKGVER\\n pkgrel = settings.SALT_AUR_PKGREL\\n response = urllib2.urlopen(\\\"https://aur.archlinux.org/packages/sa/salt/PKGBUILD\\\")\\n for line in response:\\n if line.startswith(\\\"pkgver=\\\") and not pkgver in line:\\n abort(\\\"The requested Salt 'pkgrel={0}' in the AUR was updated to '{1}'.\\\".format(\\n pkgver, line.strip()))\\n if line.startswith(\\\"pkgrel=\\\") and not pkgrel in line:\\n abort(\\\"The requested Salt 'pkgrel={0}' in the AUR was updated to '{1}'.\\\".format(\\n pkgrel, line.strip()))\",\n \"def check_version(ctx, _, value):\\n if not value or ctx.resilient_parsing:\\n return\\n\\n click.echo(f\\\"geocube v{importlib.metadata.version('geocube')}\\\")\\n\\n ctx.exit()\",\n \"def test_schema_version(self):\\n\\n self.validator.adata.uns[\\\"schema_version\\\"] = \\\"1.0.0\\\"\\n self.validator.validate_adata()\\n self.assertEqual(\\n self.validator.errors,\\n [\\n \\\"ERROR: Schema version '1.0.0' is not supported. Current supported versions: '['2.0.0']'. \\\"\\n \\\"Validation cannot be performed.\\\"\\n ],\\n )\",\n \"def validate_project_version(config: Dict[str, Any]) -> None:\\n spacy_version = config.get(\\\"spacy_version\\\", None)\\n if spacy_version and not is_compatible_version(about.__version__, spacy_version):\\n err = (\\n f\\\"The {PROJECT_FILE} specifies a spaCy version range ({spacy_version}) \\\"\\n f\\\"that's not compatible with the version of spaCy you're running \\\"\\n f\\\"({about.__version__}). You can edit version requirement in the \\\"\\n f\\\"{PROJECT_FILE} to load it, but the project may not run as expected.\\\"\\n )\\n msg.fail(err, exits=1)\",\n \"def test_valid_hh_version():\\n # TODO: Basically only enforcing correct main segment, since not using `re.fullmatch`\\n # TODO: Probably want `re.fullmatch` here - Currently ignoring any potentially invalid suffix\\n version_pattern = r\\\"^[0-9]+\\\\.[0-9]+\\\\.[0-9]+(|a[0-9]|b[0-9]|rc[0-9])\\\"\\n res = re.match(version_pattern, hh.__version__)\\n assert res is not None\",\n \"def test_versionString(self):\\n self.assertIn(\\\"%d.%d.%d\\\" % nevow.__version_info__, nevow.__version__)\",\n \"def test_version():\\n with open(\\\"pyproject.toml\\\") as f:\\n tomllines = f.read().splitlines()\\n tomlversion = set([l for l in tomllines if \\\"version =\\\" in l])\\n initversion = set([f'version = \\\"{mei2volpiano.__version__}\\\"'])\\n # set is there to catch any duplicate/additional entries\\n assert initversion == tomlversion\",\n \"def validate_required_python_version_running(minimal_required_version: str) -> None:\\n try:\\n parts = minimal_required_version.split(\\\".\\\")\\n min_py_version = 1000000*int(parts[0]) + 1000*(int(parts[1]) if len(parts) > 1 else 0) + (int(parts[2]) if len(parts) > 2 else 0)\\n running_py_version = 1000000*sys.version_info.major + 1000*sys.version_info.minor + sys.version_info.micro\\n if running_py_version < min_py_version:\\n raise RuntimeError(\\\"\\\")\\n except:\\n raise RuntimeError(f\\\"Kqlmagic requires python >= {Constants.MINIMAL_PYTHON_VERSION_REQUIRED}, you use python {sys.version}\\\")\",\n \"def check_version(self, node):\\n assert \\\"version\\\" in node, \\\"Version node does not contain attribute 'version'\\\"\\n assert len(node[\\\"version\\\"]) >= 1, \\\"Expecting at least one 'version' value\\\"\\n # TODO: add more thorough checks\",\n \"def validate_backend_version(self):\\n pass\",\n \"def validate_version(version):\\n matched = VERSION_REGEX.match(version)\\n if matched is None:\\n print_stderr(\\\"Version '{0}' does not match version regex\\\".format(version))\\n return\\n\\n # Format is syntactically valid\\n version_dict = matched.groupdict()\\n\\n # Check dependents\\n dependencies = [(\\\"special_sep\\\", \\\"special\\\"), (\\\"special\\\", \\\"special_sep\\\"), (\\\"index_sep\\\", \\\"index\\\"), (\\\"index\\\", \\\"index_sep\\\"), (\\\"index\\\", \\\"special\\\"), (\\\"special\\\", \\\"index\\\")]\\n for dependent, dependency in dependencies:\\n if version_dict[dependent] and not version_dict[dependency]:\\n print_stderr(\\\"Version '{0}' is invalid: '{1}' is defined but not '{2}'\\\".format(version, dependent, dependency))\\n return None\\n\\n # Remove noise\\n for noise in [\\\"special_sep\\\", \\\"index_sep\\\"]:\\n del version_dict[noise]\\n\\n return version_dict\",\n \"def test_pynast_suported_version(self):\\r\\n min_acceptable_version = (1, 2)\\r\\n max_acceptable_version = (1, 2, 2)\\r\\n try:\\r\\n from pynast import __version__ as pynast_lib_version\\r\\n version = pynast_lib_version.split('.')\\r\\n if version[-1][-4:] == '-dev':\\r\\n version[-1] = version[-1][:-4]\\r\\n version = tuple(map(int, version))\\r\\n pass_test = (version >= min_acceptable_version and\\r\\n version <= max_acceptable_version)\\r\\n version_string = str(pynast_lib_version)\\r\\n except ImportError:\\r\\n pass_test = False\\r\\n version_string = \\\"Not installed\\\"\\r\\n\\r\\n min_version_str = '.'.join(map(str, min_acceptable_version))\\r\\n max_version_str = '.'.join(map(str, max_acceptable_version))\\r\\n error_msg = (\\\"Unsupported pynast version. Must be >= %s and <= %s, \\\"\\r\\n \\\"but running %s.\\\" % (min_version_str, max_version_str,\\r\\n version_string))\\r\\n self.assertTrue(pass_test, error_msg)\",\n \"def package_version_check(args, parser):\\n if (args.build or args.check) and args.package_version:\\n parser.error('--package-version works only with --create')\",\n \"def test_version_missing(self):\\r\\n self.assertIsNone(self._version_test(self.no_version))\",\n \"def check_version(ctx, builder, version_function, *,\\n requires_version=None,\\n requires_at_least_version=None,\\n requires_at_most_version=None):\\n if any(v is not None for v in (\\n requires_version,\\n requires_at_least_version,\\n requires_at_most_version)):\\n ctx.logger.check('checking %s version' % builder)\\n\\n version_str = version_function()\\n\\n # Convert the version into a tuple\\n version = []\\n for i in version_str.split('.'):\\n try:\\n version.append(int(i))\\n except ValueError:\\n # The subversion isn't a number, so just convert it to a\\n # string.\\n version.append(i)\\n version = tuple(version)\\n\\n if requires_version is not None and requires_version != version:\\n msg = 'version %s required; found %s' % (\\n '.'.join(str(i) for i in requires_version), version_str)\\n\\n ctx.logger.failed(msg)\\n raise fbuild.ConfigFailed(msg)\\n\\n if requires_at_least_version is not None and \\\\\\n requires_at_least_version > version:\\n msg = 'at least version %s required; found %s' % (\\n '.'.join(str(i) for i in requires_at_least_version),\\n version_str)\\n\\n ctx.logger.failed(msg)\\n raise fbuild.ConfigFailed(msg)\\n\\n if requires_at_most_version is not None and \\\\\\n requires_at_most_version < version:\\n msg = 'at most version %s required; found %s' % (\\n '.'.join(str(i) for i in requires_at_most_version),\\n version_str)\\n\\n ctx.logger.failed(msg)\\n raise fbuild.ConfigFailed(msg)\\n\\n ctx.logger.passed(version_str)\",\n \"def test_version(self):\\n version_instance = get_version('kolibri', __file__)\\n self.assertIn(version_instance.major_version, kolibri.__version__)\",\n \"def test_version():\\n versions = ((2, 7, 16), (3, 5, 7), (3, 6, 8), (3, 7, 3))\\n assert sys.version_info[:3] in versions\",\n \"def test_version(self) -> None:\\n with open(\\\"pyproject.toml\\\") as f:\\n for line in f:\\n if \\\"version\\\" in line:\\n version = line.split()[-1].replace('\\\"', \\\"\\\")\\n break\\n self.assertEqual(__version__, version)\",\n \"def check_from_version(version: str) -> str:\\n version_int = [int(v) for v in version.split(\\\".\\\")]\\n if version_int[0] not in PipetteModelMajorVersion:\\n raise ValueError(f\\\"Major version {version_int[0]} is not supported.\\\")\\n if version_int[1] not in PipetteModelMinorVersion:\\n raise ValueError(f\\\"Minor version {version_int[1]} is not supported.\\\")\\n return version\",\n \"def is_version_valid(version):\\n return _compiled_version_regex.match(version) is not None\",\n \"def _checkUpdateNeeded(self):\\n try:\\n currentVersionLine = str(subprocess.run(['pacman', '-Q', '-i', self._name],\\n stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=True).stdout)\\n currentVersion = re.sub(r'.*Version\\\\s*: ([\\\\d|\\\\.]*)-.*', r'\\\\1', currentVersionLine).split('.')\\n newVersion = self._version.split('.')\\n for i in range(0, min(len(currentVersion), len(newVersion))):\\n if currentVersion[i].isdigit():\\n # TODO: test if new version is only digits too, two of them should be the same anyway\\n if int(newVersion[i]) > int(currentVersion[i]):\\n return True\\n if int(newVersion[i]) < int(currentVersion[i]):\\n return False\\n return len(newVersion) > len(currentVersion)\\n except subprocess.CalledProcessError:\\n # Package not found: to be installed then\\n return True\",\n \"def check_version_is_supported(name, version, min_version, help=''):\\n if (pkg_resources.parse_version(version) <\\n pkg_resources.parse_version(min_version)):\\n # Version is too old.\\n print('ERROR: Unsupported %s version: %s (minimum %s).%s' %\\n (name, version, min_version, (' %s' % help) if help else ''),\\n file=sys.stderr)\\n exit(1)\",\n \"def check_version_2(dataset):\\n\\n if float(dataset.get('version')) >= 2.0 \\\\\\n if dataset.get('version') else False:\\n return True\\n else:\\n return False\",\n \"def check_version():\\n reset_flag = False\\n try:\\n data = du.read_yml(du.DEFAULT)\\n if (\\n data[\\\"version\\\"].split(\\\".\\\")[0] != __version__.split(\\\".\\\")[0]\\n ): # If Version if different from \\\"1.x.y\\\" remove data:\\n reset_flag = True\\n except (KeyError, FileNotFoundError, TypeError):\\n reset_flag = True\\n\\n if reset_flag:\\n print(\\\"Your configuration file version is older than 1.0.0\\\")\\n print(\\n \\\"Your .Experiment file will be removed, please run daf.init to generate an up-to-date file\\\"\\n )\\n if os.path.isfile(du.DEFAULT):\\n os.remove(du.DEFAULT)\\n sys.exit(0)\",\n \"def is_valid_version(self) -> bool:\\n return self._is_valid_version()\",\n \"def check_all():\\n for package, version in required_versions.items():\\n try:\\n module = importlib.import_module(package)\\n except ImportError:\\n return\\n else:\\n if StrictVersion(version) > StrictVersion(module.__version__):\\n raise RuntimeError(\\\"Your version of %s is too old - it must be at least %s\\\" % (\\n package,\\n version,\\n ))\",\n \"def check_version_part(self, node, ecosystem, package, version):\\n version_node = node[\\\"version\\\"]\\n # check the ecosystem, version, and name attributes that are required for a version\\n self.check_pecosystem(version_node)\\n self.check_pname(version_node)\\n self.check_version(version_node)\\n\\n # compare with expected values\\n e = version_node[\\\"pecosystem\\\"][0]\\n p = version_node[\\\"pname\\\"][0]\\n v = version_node[\\\"version\\\"][0]\\n self.compare_ecosystems(e, ecosystem)\\n self.compare_packages(p, package)\\n self.compare_versions(v, version)\",\n \"def check_py_version(self, cur_version):\\n\\n # convert cur_version to string, in case of erroneous type being passed\\n cur_version = str(cur_version)\\n\\n acceptable_python_versions_regex = r\\\"(^(2\\\\.[6-9])(\\\\.?\\\\d{1,2})?$)|(^(3\\\\.[3-9])(\\\\.?\\\\d{1,2})?$)\\\"\\n pyversions_regex_compiled = re.compile(acceptable_python_versions_regex)\\n pyversions_match = pyversions_regex_compiled.match(cur_version)\\n\\n # If match is found, return True. If no match, return False\\n if pyversions_match:\\n return True\\n else:\\n return False\",\n \"def test_versioning_unknown_version(workflow_runner):\\n with pytest.raises(WDL.Error.SyntaxError):\\n workflow_runner(\\\"test_versioning_unknown_version.wdl\\\")\",\n \"def check_openhpiver(reqver_text):\\n\\treturn check_pkgcfg_ver(reqver_text, 'openhpi')\",\n \"def check_cal_format_version(version: Optional[Version] = None, current_version: Version = _CAL_FORMAT_VERSION):\\n # No version means, the old 1.0 format is used that does not provide a version string\\n if not version:\\n version = Version(\\\"1.0.0\\\")\\n if isinstance(version, str):\\n version = Version(version)\\n\\n if version == current_version:\\n return\\n if version > current_version:\\n raise ValueError(\\\"The provided version, is larger than the currently supported version.\\\")\\n if version < current_version:\\n raise ValueError(\\n \\\"The provided calibration format is no longer supported. \\\"\\n \\\"Check `imucal.legacy` if conversion helper exist.\\\"\\n )\",\n \"def checkVersion(self, clientName, edamVersionMajor, edamVersionMinor):\\r\\n pass\",\n \"def test_patch_hyperflex_software_version_policy(self):\\n pass\",\n \"def test_lowest_version(self):\\n self.assertEqual({\\\"python-xyz\\\": \\\"1\\\",\\n \\\"python-foo\\\": \\\"3.1\\\"},\\n pr.sanitize_requirements(\\n [\\\"xyz>=1,>=2\\\", \\\"foo>=4,>=3.1\\\"]))\",\n \"def python_version_check():\\n min_version_list = PYTHON_MIN_VERSION.split(\\\".\\\")\\n # Truncate if the list is more the 4 items\\n if len(min_version_list) > 4:\\n min_version_list = min_version_list[:4]\\n # Fill if the list is less then 4 items\\n if len(min_version_list) == 1:\\n min_version_list.append(\\\"0\\\")\\n if len(min_version_list) == 2:\\n min_version_list.append(\\\"0\\\")\\n if len(min_version_list) == 3:\\n min_version_list.append(\\\"f0\\\")\\n # Calculate the minimum version and an integer, which, when displayed as\\n # hex, is easily recognised as the version. E.g. 0x30502f0 is 3.5.2\\n min_version_value = 0\\n for index, item in enumerate(min_version_list[::-1]):\\n min_version_value = min_version_value + int(item, 16) * 2**(index * 8)\\n if debug: print(\\\"Python Version Minimum:{}, Decimal:{}, Hex:{}\\\"\\n .format(PYTHON_MIN_VERSION, min_version_value,\\n hex(min_version_value)))\\n # test value and exit if below minimum revision\\n if sys.hexversion < min_version_value:\\n print(\\\"Python Version: {}. Required minimum version is: {}. Exiting...\\\"\\n .format(sys.version.split(\\\" \\\")[0], PYTHON_MIN_VERSION))\\n sys.exit()\",\n \"def _verify_patchelf() -> None:\\n if not find_executable(\\\"patchelf\\\"):\\n raise ValueError(\\\"Cannot find required utility `patchelf` in PATH\\\")\\n try:\\n version = check_output([\\\"patchelf\\\", \\\"--version\\\"]).decode(\\\"utf-8\\\")\\n except CalledProcessError:\\n raise ValueError(\\\"Could not call `patchelf` binary\\\")\\n\\n m = re.match(r\\\"patchelf\\\\s+(\\\\d+(.\\\\d+)?)\\\", version)\\n if m and tuple(int(x) for x in m.group(1).split(\\\".\\\")) >= (0, 14):\\n return\\n raise ValueError(\\n f\\\"patchelf {version} found. auditwheel repair requires \\\" \\\"patchelf >= 0.14.\\\"\\n )\",\n \"def check_versioning(ctx, stmt):\\n\\n # Don't perform this check for modules that are not OpenConfig\\n # or are OpenConfig infrastructure (e.g., extensions)\\n if (OCLintFunctions.is_openconfig_validatable_module(stmt.arg) in\\n [ModuleType.NONOC, ModuleType.OCINFRA]):\\n return\\n\\n version = None\\n for substmt in stmt.substmts:\\n # pyang uses a keyword tuple when the element is from\\n # an external extension rather than a built-in, check for\\n # this before checking the argument. Assumption is made\\n # that openconfig-version is unique across all extension\\n # modules.\\n if (isinstance(substmt.keyword, tuple) and\\n substmt.keyword[1] == \\\"openconfig-version\\\"):\\n version = substmt\\n\\n if version is None:\\n err_add(ctx.errors, stmt.pos, \\\"OC_MODULE_MISSING_VERSION\\\",\\n stmt.arg)\\n return\\n\\n if not re.match(r\\\"^[0-9]+\\\\.[0-9]+\\\\.[0-9]+$\\\", version.arg):\\n err_add(ctx.errors, stmt.pos, \\\"OC_INVALID_SEMVER\\\",\\n version.arg)\\n\\n # Check that there\\n match_revision = False\\n for revision_stmt in stmt.search(\\\"revision\\\"):\\n reference_stmt = revision_stmt.search_one(\\\"reference\\\")\\n if reference_stmt is not None and reference_stmt.arg == version.arg:\\n match_revision = True\\n\\n if match_revision is False:\\n err_add(ctx.errors, stmt.pos, \\\"OC_MISSING_SEMVER_REVISION\\\",\\n version.arg)\",\n \"def version_match(required, candidate):\\n return _discover.version_match(required, candidate)\",\n \"def solr_version_check(core):\\n expected_version = SCHEMA[core].version\\n solr_uri = config.CFG.get(\\\"solr\\\", \\\"uri\\\")\\n u = urllib2.urlopen(\\\"%s/%s/schema/version\\\" % (solr_uri, core))\\n content = loads(u.read())\\n seen_version = content[\\\"version\\\"]\\n if not seen_version == expected_version:\\n raise VersionMismatchException(core, expected_version, seen_version)\\n logger.debug(\\\"%s: version %1.1f matches %1.1f\\\", core, expected_version,\\n seen_version)\",\n \"def testStratisVersion(self):\\n version = Manager.Properties.Version.Get(get_object(TOP_OBJECT))\\n (major, _, _) = version.split(\\\".\\\")\\n self.assertEqual(major, \\\"0\\\")\",\n \"def test_required_fields_schema_version(self):\\n\\n del self.validator.adata.uns[\\\"schema_version\\\"]\\n self.validator.validate_adata()\\n self.assertEqual(\\n self.validator.errors,\\n [\\n \\\"ERROR: adata has no schema definition in 'adata.uns'. \\\"\\n \\\"Validation cannot be performed.\\\"\\n ],\\n )\",\n \"def is_stable_version(version):\\n if not isinstance(version, tuple):\\n version = version.split('.')\\n last_part = version[-1]\\n\\n if not re.search('[a-zA-Z]', last_part):\\n return True\\n else:\\n return False\",\n \"def _check_version () -> None:\\n py_version_info: typing.Tuple = sys.version_info[:2]\\n\\n if py_version_info < MIN_PY_VERSION:\\n error_msg = \\\"This version of pytextrank requires Python {} or later ({} detected)\\\\n\\\"\\n raise RuntimeError(error_msg.format(_versify(MIN_PY_VERSION), _versify(py_version_info)))\",\n \"def assert_version(version, minimum=VERSION_MINIMUM, maximum=VERSION_MAXIMUM, blacklist=VERSION_BLACKLIST):\\n\\t# Convert version strings to integer tuples\\n\\tversion = list(map(int, version.split('-', 1)[0].split('.')))\\n\\tminimum = list(map(int, minimum.split('-', 1)[0].split('.')))\\n\\tmaximum = list(map(int, maximum.split('-', 1)[0].split('.')))\\n\\n\\tif minimum > version or version >= maximum:\\n\\t\\traise exceptions.VersionMismatch(version, minimum, maximum)\\n\\t\\n\\tfor blacklisted in blacklist:\\n\\t\\tblacklisted = list(map(int, blacklisted.split('-', 1)[0].split('.')))\\n\\t\\tif version == blacklisted:\\n\\t\\t\\traise exceptions.VersionMismatch(version, minimum, maximum)\",\n \"def _check_python_version(self):\\n python_exe = tools.which(\\\"python\\\")\\n if not python_exe:\\n msg = (\\\"Python must be available in PATH \\\"\\n \\\"in order to build v8\\\")\\n raise ConanInvalidConfiguration(msg)\\n # In any case, check its actual version for compatibility\\n from six import StringIO # Python 2 and 3 compatible\\n version_buf = StringIO()\\n cmd_v = \\\"{} --version\\\".format(python_exe)\\n self.run(cmd_v, output=version_buf)\\n p = re.compile(r'Python (\\\\d+\\\\.\\\\d+\\\\.\\\\d+)')\\n verstr = p.match(version_buf.getvalue().strip()).group(1)\\n if verstr.endswith('+'):\\n verstr = verstr[:-1]\\n version = tools.Version(verstr)\\n # >= 2.7.5 & < 3\\n py2_min = \\\"2.7.5\\\"\\n py2_max = \\\"3.0.0\\\"\\n py3_min = \\\"3.8.0\\\"\\n if (version >= py2_min) and (version < py2_max):\\n msg = (\\\"Found valid Python 2 required for v8:\\\"\\n \\\" version={}, path={}\\\".format(version_buf.getvalue().strip(), python_exe))\\n self.output.success(msg)\\n elif version >= py3_min:\\n msg = (\\\"Found valid Python 3 required for v8:\\\"\\n \\\" version={}, path={}\\\".format(version_buf.getvalue().strip(), python_exe))\\n self.output.success(msg)\\n else:\\n msg = (\\\"Found Python in path, but with invalid version {}\\\"\\n \\\" (v8 requires >= {} and < \\\"\\n \\\"{} or >= {})\\\".format(verstr, py2_min, py2_max, py3_min))\\n raise ConanInvalidConfiguration(msg)\",\n \"def test_pre_release(scraper, version_parts):\\n\\n new_version_parts = list(version_parts)\\n if len(new_version_parts) > 4:\\n new_version_parts[4] = int(new_version_parts[4]) + 1\\n elif len(new_version_parts) > 3:\\n new_version_parts.append(1)\\n else:\\n new_version_parts.extend(['a', 1])\\n\\n assert scraper.is_compatible_with(generate_version(new_version_parts)) is True\",\n \"def checkIfVersionIsExact(testConfig):\\n assert \\\"name\\\" in testConfig\\n assert \\\"binary\\\" in testConfig\\n assert \\\"version\\\" in testConfig\\n \\n #Set default version command as \\\"testConfig[\\\"name\\\"] --version\\\"\\n #Otherwise, use testConfig[\\\"version_command\\\"]\\n if \\\"version_command\\\" in testConfig:\\n versionCommand = testConfig[\\\"version_command\\\"]\\n else:\\n versionCommand = testConfig[\\\"binary\\\"]+r\\\" --version\\\"\\n \\n #Run the version command, grab stdout and stderr\\n p = subprocess.Popen(versionCommand.split(), stdout=subprocess.PIPE,stderr=subprocess.PIPE)\\n versionOut,versionError = p.communicate()\\n versionOut = str(versionOut)+str(versionError)\\n \\n #Find all instances of something that could be the version number in the output\\n installedVersion = re.findall(r\\\"([0-9.]*[0-9]+)\\\", versionOut)\\n \\n #Go through all the matches, if anything starts with our expected version,\\n #Set test as pass\\n testPass=False\\n for version in installedVersion:\\n if re.match(testConfig[\\\"version\\\"],str(version)) :\\n testPass=True\\n break\\n \\n \\n assert testPass,\\\"\\\\nVersion output was :\\\"+versionOut+\\\\\\n \\\"\\\\nExpected version: \\\"+testConfig[\\\"version\\\"]+\\\\\\n \\\"\\\\n Test failed.\\\"\",\n \"def _check_version(version):\\n # Update cache if needed.\\n if _check_version._versions_cache is None:\\n log.debug(\\\"Loading versions cache ...\\\")\\n _check_version._versions_cache = __salt__[\\\"netbeans.list_versions\\\"]()\\n\\n # Convert latest.\\n if version is None or version == \\\"latest\\\":\\n return __salt__[\\\"netbeans.pick_latest_version\\\"](\\n _check_version._versions_cache\\n )\\n\\n # Check if version is available.\\n if version not in _check_version._versions_cache:\\n return None\\n return version\",\n \"def test1_version(self):\\n lVersion = rdbhdb.__version__.split('.')\\n nVersion = need_version.split('.')\\n self.assert_(lVersion >= nVersion, rdbhdb.__version__)\",\n \"def check_version_str(version):\\n if not version.startswith('v') and version != 'current':\\n version = 'v%s' % version\\n return version\",\n \"def validate_available(parser, options):\\n if not options.available:\\n return\\n\\n if not options.manifest_id:\\n parser.error(\\\"When specifying --available, --manifest-id is also required\\\")\",\n \"def test_arg_version(run_nait) -> None: # type: ignore\\n expected = nanaimo.version.__version__\\n assert run_nait(['--version']).stdout.decode('utf-8').startswith(expected)\",\n \"def valid_version(self, new_version):\\n if not re.match(r\\\"\\\\d+\\\\.\\\\d+\\\\.\\\\d+\\\", new_version):\\n return False\\n\\n x1, y1, z1 = [int(i) for i in self.current_version().split(\\\".\\\")]\\n x2, y2, z2 = [int(i) for i in new_version.split(\\\".\\\")]\\n\\n if x2 < x1:\\n return False\\n\\n if x2 == x1 and y2 < y1:\\n return False\\n\\n if x2 == x1 and y2 == y1 and z2 <= z1:\\n return False\\n\\n return True\",\n \"def _check_required(self):\\n if self.data['history_file'] is None:\\n return\\n required = self.data.get('required_changelog_text')\\n if not required:\\n return\\n if isinstance(required, six.string_types):\\n required = [required]\\n history_last_release = self.data['history_last_release']\\n for text in required:\\n if text in history_last_release:\\n # Found it, all is fine.\\n return\\n pretty_required = '\\\"{}\\\"'.format('\\\", \\\"'.join(required))\\n if not utils.ask(\\n \\\"WARNING: Changelog should contain at least one of \\\"\\n \\\"these required strings: {}. Are you sure you \\\"\\n \\\"want to release?\\\".format(pretty_required),\\n default=False):\\n sys.exit(1)\",\n \"def test_above_24_latest_version(self):\\n self.data['version'] = ''\\n self.data['appVersion'] = '28.0'\\n\\n up = self.get(self.data)\\n rdf = up.get_rdf()\\n assert rdf.find('20202020.01') > -1\",\n \"def require_version(version):\\n def check_require_version(f):\\n version_elements = version.split('.')\\n try:\\n compare = tuple([int(v) for v in version_elements])\\n except ValueError:\\n raise ValueError('%s is not a correct version : should be X.Y[.Z].' % version)\\n current = sys.version_info[:3]\\n if current < compare:\\n def new_f(self, *args, **kwargs):\\n self.skipTest('Need at least %s version of python. Current version is %s.' % (version, '.'.join([str(element) for element in current])))\\n new_f.__name__ = f.__name__\\n return new_f\\n else:\\n return f\\n return check_require_version\",\n \"def _sanityCheckProtocolVersions(other):\\n if other.minVersion > other.maxVersion:\\n raise ValueError(\\\"Versions set incorrectly\\\")\\n if other.minVersion not in KNOWN_VERSIONS:\\n raise ValueError(\\\"minVersion set incorrectly\\\")\\n if other.maxVersion not in KNOWN_VERSIONS:\\n raise ValueError(\\\"maxVersion set incorrectly\\\")\\n\\n if other.maxVersion < (3, 4):\\n other.versions = [i for i in other.versions if i < (3, 4)]\",\n \"def test_undefined_semver(self):\\n v1 = versions.Version(version='1.2.3', name='foo')\\n expected = None\\n\\n self.assertEqual(v1.build, expected)\",\n \"def test_version(self, parse_input):\\n bb = parse_input(\\\"name testname\\\\nversion 1.0\\\")\\n assert bb.version == \\\"1.0\\\"\\n\\n bb = parse_input(\\\"name testname\\\\nversion 1.12\\\")\\n assert bb.version == \\\"1.12\\\"\",\n \"def test_parse_invalid_version(self):\\n version = VersionNumberScaleMeasurement.parse_version(\\\"This is not a version number\\\")\\n self.assertEqual(Version(\\\"0\\\"), version)\",\n \"def check_schema_version(context, version):\\n data = context.response.json()\\n check_and_get_attribute(data, version)\",\n \"def _check_server_version(self, server_version: str) -> None:\\n cur_version = parse_version(server_version)\\n min_version = parse_version(MIN_SERVER_VERSION)\\n if cur_version < min_version:\\n raise InvalidServerVersion\\n if cur_version != min_version:\\n self._logger.warning(\\n \\\"Connected to a Zwave JS Server with an untested version, \\\\\\n you may run into compatibility issues!\\\"\\n )\",\n \"def checkIfMinimumVersionIsMet(testConfig):\\n assert \\\"name\\\" in testConfig\\n assert \\\"binary\\\" in testConfig\\n assert \\\"minimum_version\\\" in testConfig\\n \\n #Set default version command as \\\"testConfig[\\\"name\\\"] --version\\\"\\n #Otherwise, use testConfig[\\\"version_command\\\"]\\n if \\\"version_command\\\" in testConfig:\\n versionCommand = testConfig[\\\"version_command\\\"]\\n else:\\n versionCommand = testConfig[\\\"binary\\\"]+r\\\" --version\\\"\\n \\n #Run the version command, grab stdout and stderr\\n p = subprocess.Popen(versionCommand.split(), stdout=subprocess.PIPE,stderr=subprocess.PIPE)\\n versionOut,versionError = p.communicate()\\n versionOut = str(versionOut)+str(versionError)\\n \\n #Find all instances of something that could be the version number in the output\\n installedVersion = re.findall(r\\\"([0-9]+\\\\.)+[0-9]+\\\", versionOut)\\n \\n #Go through all the matches, if anything starts with our expected version,\\n #Set test as pass\\n testPass=False\\n for version in installedVersion:\\n if LooseVersion(str(version)) >= LooseVersion(testConfig[\\\"minimum_version\\\"]):\\n testPass=True\\n break\\n \\n assert testPass,\\\"\\\\nVersion output was :\\\"+versionOut+\\\\\\n \\\"\\\\nExpected minimum version: \\\"+testConfig[\\\"minimum_version\\\"]+\\\\\\n \\\"\\\\n Test failed.\\\"\",\n \"def test_major(scraper, version_parts):\\n\\n new_version_parts = list(version_parts)\\n new_version_parts[0] = int(new_version_parts[0]) + 1\\n\\n assert scraper.is_compatible_with(generate_version(new_version_parts)) is False\",\n \"def test_version_exists():\\n assert ztm.__version__\",\n \"def test_minor(scraper, version_parts):\\n\\n new_version_parts = list(version_parts)\\n new_version_parts[1] = int(new_version_parts[1]) + 1\\n\\n assert scraper.is_compatible_with(generate_version(new_version_parts)) is True\",\n \"def check_version(min_version: str,\\n warning_only: bool = False,\\n library: Optional[ModuleType] = None):\\n # pylint: disable=import-outside-toplevel\\n from .. import __version__\\n if library is None:\\n version = __version__\\n name = 'GluonNLP'\\n else:\\n version = library.__version__\\n name = library.__name__\\n from packaging.version import parse\\n bad_version = parse(version.replace('.dev', '')) < parse(min_version)\\n if bad_version:\\n msg = 'Installed {} version {} does not satisfy the ' \\\\\\n 'minimum required version {}'.format(name, version, min_version)\\n if warning_only:\\n warnings.warn(msg)\\n else:\\n raise AssertionError(msg)\",\n \"def check_pythonver(reqver_text):\\n\\treqver = map(int, reqver_text.split('.'))\\n\\tpythonver = sys.version_info[:3]\\n\\treturn check_ver(pythonver, reqver)\",\n \"def test_versioned_release_schema():\\n path = 'versioned-release-validation-schema.json'\\n if os.path.exists(path):\\n warn_and_assert([path], '{0} is present, run: rm {0}',\\n 'Versioned release schema files are present. See warnings below.')\",\n \"def check_version():\\n err = \\\"PaddlePaddle version 1.6 or higher is required, \\\" \\\\\\n \\\"or a suitable develop version is satisfied as well. \\\\n\\\" \\\\\\n \\\"Please make sure the version is good with your code.\\\" \\\\\\n\\n try:\\n fluid.require_version('1.6.0')\\n except Exception as e:\\n logger.error(err)\\n sys.exit(1)\",\n \"def check_python_version(match, current=None):\\n if current is None:\\n current = list(sys.version_info[:3])\\n if not isinstance(match, list):\\n match = [match]\\n for m in match:\\n minimal = False\\n if isinstance(m, float):\\n m = str(m)\\n if m.endswith(\\\"+\\\"):\\n minimal = True\\n m = m[:-1]\\n # assert m[0].isdigit()\\n # assert m[-1].isdigit()\\n m = [int(x) for x in m.split(\\\".\\\")]\\n current_len = current[: len(m)]\\n # print(m, current, current_len)\\n if minimal:\\n if current_len >= m:\\n return True\\n else:\\n if current_len == m:\\n return True\\n return False\",\n \"def test_local_version(self):\\n self.assertIsInstance(__version__, float)\",\n \"def is_version_2_6() -> bool:\\n v = get_version()\\n if v[1] != \\\"singularity\\\" and v[1] != \\\"singularity-ce\\\":\\n return False\\n return v[0][0] == 2 and v[0][1] == 6\",\n \"def compatible_version(self):\\n note_version = self.py_version\\n py_version = sys.version_info\\n if note_version[0] != py_version[0]:\\n return False\\n if len(note_version) > 1 and note_version[1] > py_version[1]:\\n return False\\n return True\",\n \"def test_versionInfo(self):\\n self.assertEqual(\\n nevow.__version_info__,\\n (nevow.version.major, nevow.version.minor, nevow.version.micro))\",\n \"def _is_version_uptodate(self):\\n logging.info(\\\"Checking tesseract version\\\")\\n cmd = '%s -v' % (self.binary)\\n logging.info(cmd) \\n try:\\n ret_output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)\\n except CalledProcessError:\\n # Could not run tesseract\\n error(self.msgs['TS_MISSING'])\\n\\n ver_str = '0.0.0'\\n for line in ret_output.splitlines():\\n if 'tesseract' in line:\\n ver_str = line.split(' ')[1]\\n if ver_str.endswith('dev'): # Fix for version strings that end in 'dev'\\n ver_str = ver_str[:-3]\\n\\n # Iterate through the version dots\\n ver = [int(x) for x in ver_str.split('.')]\\n req = [int(x) for x in self.required.split('.')]\\n\\n # Aargh, in windows 3.02.02 is reported as version 3.02 \\n # SFKM\\n if str(os.name) == 'nt':\\n req = req[:2]\\n\\n version_good = False\\n for i,num in enumerate(req):\\n if len(ver) < i+1:\\n # This minor version number is not present in tesseract, so it must be\\n # lower than required. (3.02 < 3.02.01)\\n break\\n if ver[i]==num and len(ver) == i+1 and len(ver)==len(req):\\n # 3.02.02 == 3.02.02\\n version_good = True\\n continue\\n if ver[i]>num:\\n # 4.0 > 3.02.02\\n # 3.03.02 > 3.02.02\\n version_good = True\\n break\\n if ver[i]<num:\\n # 3.01.02 < 3.02.02\\n break\\n \\n return version_good, ver_str\",\n \"def test_invalid_version_fields(self):\\n self.assertRaises(ValueError, versions.Version, version='1234', name='foo')\",\n \"def model_is_valid(self, model: OscalBaseModel) -> bool:\\n oscal_version = model.metadata.oscal_version.__root__\\n p = re.compile(OSCAL_VERSION_REGEX)\\n matched = p.match(oscal_version)\\n return matched is not None\",\n \"def check_package_version(self, node, ecosystem, package, version):\\n assert \\\"package\\\" in node, \\\"'package' node is expected\\\"\\n assert \\\"version\\\" in node, \\\"'version' node is expected\\\"\\n self.check_package_part(node, ecosystem, package)\\n self.check_version_part(node, ecosystem, package, version)\\n # TODO: add more thorough checks\",\n \"def test_invalid_version_ints(self):\\n self.assertRaises(ValueError, versions.Version, version='1a.2', name='foo')\",\n \"def checkPatchValidity(val):\\n\\n tag_list = val.split('-')\\n if len(tag_list) < 5:\\n return False\\n\\n if tag_list[0] not in os.environ.get('environment'):\\n return False\\n\\n if tag_list[1] not in os.environ.get('platform'):\\n return False\\n\\n if tag_list[2] not in os.environ.get('role'):\\n return False \\n\\n if tag_list[3] not in os.environ.get('urgency'):\\n return False \\n\\n if tag_list[4] not in os.environ.get('order'):\\n return False\\n\\n return True\",\n \"def _check_package_version(package, min_version):\\n # Re-raise with a more informative message when the package is not\\n # installed\\n try:\\n module = import_module(package)\\n except ModuleNotFoundError:\\n raise ModuleNotFoundError(\\\"Please install {0} with a version >= \\\"\\n \\\"{1} in order to install scikit-lr.\\\"\\n .format(package, min_version))\\n\\n if LooseVersion(module.__version__) < min_version:\\n raise ValueError(\\\"The current version of {0} is {1} installed in {2}.\\\"\\n .format(package, module.__version__, module.__path__))\",\n \"def test_update_hyperflex_software_version_policy(self):\\n pass\",\n \"def test_version_check_update_available(self):\\n output = self.run_command(\\\"selfupdate --check bennr01:selfupdate_test_future\\\", exitcode=0)\\n self.assertIn(\\\"Target: bennr01:selfupdate_test_future\\\", output)\\n self.assertNotIn(\\\"Target: ywangd:master\\\", output)\\n self.assertNotIn(\\\"Already at latest version\\\", output)\\n self.assertIn(\\\"New version available\\\", output)\\n self.assertNotIn(\\\"Error: \\\", output)\",\n \"def test_Validator_is_valid_two_arguments(self):\\n\\n validator = validators.Draft7Validator({})\\n with self.assertWarns(DeprecationWarning) as w:\\n result = validator.is_valid(\\\"foo\\\", {\\\"type\\\": \\\"number\\\"})\\n\\n self.assertFalse(result)\\n self.assertEqual(w.filename, __file__)\\n self.assertTrue(\\n str(w.warning).startswith(\\n \\\"Passing a schema to Validator.is_valid is deprecated \\\",\\n ),\\n )\",\n \"def VerifyVersion(root):\\r\\n global VERSION\\r\\n global REQUIRED_VERSION\\r\\n try:\\r\\n if root.get(\\\"version\\\") < REQUIRED_VERSION:\\r\\n raise XmlVersionError(\\\"XML Version must be %s or above, we found %s!\\\" \\\\\\r\\n % (REQUIRED_VERSION, root.get(\\\"version\\\")))\\r\\n except KeyError:\\r\\n raise MalformedXmlError()\",\n \"def test_VersionOptionalFields():\\n # onlyRequiredVersion is a version message that only contains the\\n # required versions and all other values set to their default values.\\n onlyRequiredVersion = minimumMsgVersion()\\n\\n onlyRequiredVersionEncoded = baseVersionEncoded()[:-55]\\n\\n # addrMeVersion is a version message that contains all fields through\\n # the AddrMe field.\\n addrMe = netaddress.NetAddress(\\n ip=\\\"127.0.0.1\\\", port=8333, services=wire.SFNodeNetwork, stamp=0,\\n )\\n addrMeVersion = minimumMsgVersion()\\n addrMeVersion.addrMe = addrMe\\n\\n addrMeVersionEncoded = baseVersionEncoded()[:-29]\\n\\n # nonceVersion is a version message that contains all fields through\\n # the Nonce field.\\n nonceVersion = minimumMsgVersion()\\n nonceVersion.addrMe = addrMe\\n nonceVersion.nonce = 123123 # 0x1e0f3\\n nonceVersionEncoded = baseVersionEncoded()[:-21]\\n\\n # uaVersion is a version message that contains all fields through\\n # the UserAgent field.\\n uaVersion = minimumMsgVersion()\\n uaVersion.addrMe = addrMe\\n uaVersion.nonce = 123123\\n uaVersion.userAgent = \\\"/dcrdtest:0.0.1/\\\"\\n uaVersionEncoded = baseVersionEncoded()[:-4]\\n\\n # lastBlockVersion is a version message that contains all fields\\n # through the LastBlock field.\\n lastBlockVersion = minimumMsgVersion()\\n lastBlockVersion.addrMe = addrMe\\n lastBlockVersion.nonce = 123123\\n lastBlockVersion.userAgent = \\\"/dcrdtest:0.0.1/\\\"\\n lastBlockVersion.lastBlock = 234234 # 0x392fa\\n lastBlockVersionEncoded = baseVersionEncoded()\\n\\n tests = [\\n (onlyRequiredVersion, onlyRequiredVersionEncoded),\\n (addrMeVersion, addrMeVersionEncoded),\\n (nonceVersion, nonceVersionEncoded),\\n (uaVersion, uaVersionEncoded),\\n (lastBlockVersion, lastBlockVersionEncoded),\\n ]\\n\\n for expMsg, buf in tests:\\n # Decode the message from wire format.\\n msg = msgversion.MsgVersion.btcDecode(buf, wire.ProtocolVersion)\\n assert sameMsgVersion(msg, expMsg)\",\n \"def test_version():\\n assert pywren.__version__ is not None\",\n \"def is_version_sufficient(self, min_version):\\n \\n try:\\n current_version = self.get_software_version()\\n return LooseVersion(current_version) >= LooseVersion(min_version)\\n except:\\n raise\",\n \"def test_version():\\n assert(hasattr(tekel, '__version__'))\",\n \"def _verify_firmware_version(self):\\n firmware_version = self.device.firmware_version\\n self.assertTrue(firmware_version)\\n self.assertIsInstance(firmware_version, str)\",\n \"def py_versiontest(c):\\n pass\",\n \"def require_python(version_spec, warn=False, extra_msg=None, prereleases=None):\\n valid_specifiers = ('===', '==', '<=', '>=', '!=', '~=', '<', '>')\\n for spec in valid_specifiers:\\n if version_spec.startswith(spec):\\n break\\n else:\\n if version_spec[0].isdigit():\\n version_spec = f'~={version_spec}'\\n else:\\n raise InvalidSpecifier(\\n f\\\"Invalid version specifier: '{version_spec}'\\\"\\n )\\n\\n version_constraint = SpecifierSet(version_spec, prereleases=prereleases)\\n python_version = sys.version.split()[0]\\n if python_version not in version_constraint:\\n msg = (\\n \\\"The Python version installed in the environment \\\"\\n f\\\"(v{python_version}) does not satisfy the constraint \\\"\\n f\\\"'{version_constraint}'\\\"\\n )\\n if extra_msg is not None:\\n msg = f\\\"{msg}.\\\\n{extra_msg}\\\"\\n\\n if warn:\\n warnings.warn(msg, category=RuntimeWarning)\\n else:\\n raise DavosError(msg)\",\n \"def test_version(self):\\n pass\",\n \"def test_get_version(self):\\n pass\",\n \"def is_valid_version(version):\\n return bool(\\n is_valid_instance_id(version) or\\n is_valid_tag(version) or\\n REF_RE.match(version)\\n )\",\n \"def test_patch(scraper, version_parts):\\n\\n new_version_parts = list(version_parts)\\n new_version_parts[2] = int(new_version_parts[2]) + 1\\n\\n assert scraper.is_compatible_with(generate_version(new_version_parts)) is True\",\n \"def check_python_version():\\n version = sys.version.split()[0]\\n if version < \\\"2.6\\\" or version >= \\\"3\\\":\\n raise CuckooStartupError(\\\"You are running an incompatible version of Python, please use 2.6 or 2.7\\\")\",\n \"def test_get_short_version(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6902856","0.6780541","0.67345285","0.6424998","0.6407822","0.64057225","0.6383413","0.6376578","0.6337082","0.6273863","0.6264896","0.62600714","0.6233149","0.62270665","0.6219592","0.61668104","0.61236084","0.6105264","0.60952014","0.60824794","0.6016871","0.6010673","0.60073346","0.59973854","0.59782064","0.593414","0.59320503","0.5928235","0.59116226","0.59097207","0.5903058","0.5896106","0.58958584","0.5892842","0.588549","0.5882546","0.58753383","0.5873691","0.5867869","0.5862441","0.5861926","0.5859026","0.58417505","0.58380896","0.5835368","0.583349","0.5828468","0.58273476","0.58237714","0.58151007","0.5803481","0.5785615","0.5785017","0.57826674","0.5779917","0.57797605","0.5771377","0.57655334","0.575898","0.5757928","0.5754432","0.5753647","0.5732347","0.5726836","0.5724179","0.5722315","0.57212114","0.5711632","0.57081604","0.57079303","0.5706682","0.57035804","0.57007813","0.5692864","0.56843376","0.56804377","0.5679623","0.5675915","0.5675263","0.56658393","0.56657445","0.5661447","0.56581104","0.56541777","0.5650541","0.5647996","0.56440455","0.56199306","0.56167954","0.5616622","0.56149817","0.56137586","0.5610844","0.5607602","0.5606704","0.56056166","0.56049657","0.56045663","0.5603459","0.56000835"],"string":"[\n \"0.6902856\",\n \"0.6780541\",\n \"0.67345285\",\n \"0.6424998\",\n \"0.6407822\",\n \"0.64057225\",\n \"0.6383413\",\n \"0.6376578\",\n \"0.6337082\",\n \"0.6273863\",\n \"0.6264896\",\n \"0.62600714\",\n \"0.6233149\",\n \"0.62270665\",\n \"0.6219592\",\n \"0.61668104\",\n \"0.61236084\",\n \"0.6105264\",\n \"0.60952014\",\n \"0.60824794\",\n \"0.6016871\",\n \"0.6010673\",\n \"0.60073346\",\n \"0.59973854\",\n \"0.59782064\",\n \"0.593414\",\n \"0.59320503\",\n \"0.5928235\",\n \"0.59116226\",\n \"0.59097207\",\n \"0.5903058\",\n \"0.5896106\",\n \"0.58958584\",\n \"0.5892842\",\n \"0.588549\",\n \"0.5882546\",\n \"0.58753383\",\n \"0.5873691\",\n \"0.5867869\",\n \"0.5862441\",\n \"0.5861926\",\n \"0.5859026\",\n \"0.58417505\",\n \"0.58380896\",\n \"0.5835368\",\n \"0.583349\",\n \"0.5828468\",\n \"0.58273476\",\n \"0.58237714\",\n \"0.58151007\",\n \"0.5803481\",\n \"0.5785615\",\n \"0.5785017\",\n \"0.57826674\",\n \"0.5779917\",\n \"0.57797605\",\n \"0.5771377\",\n \"0.57655334\",\n \"0.575898\",\n \"0.5757928\",\n \"0.5754432\",\n \"0.5753647\",\n \"0.5732347\",\n \"0.5726836\",\n \"0.5724179\",\n \"0.5722315\",\n \"0.57212114\",\n \"0.5711632\",\n \"0.57081604\",\n \"0.57079303\",\n \"0.5706682\",\n \"0.57035804\",\n \"0.57007813\",\n \"0.5692864\",\n \"0.56843376\",\n \"0.56804377\",\n \"0.5679623\",\n \"0.5675915\",\n \"0.5675263\",\n \"0.56658393\",\n \"0.56657445\",\n \"0.5661447\",\n \"0.56581104\",\n \"0.56541777\",\n \"0.5650541\",\n \"0.5647996\",\n \"0.56440455\",\n \"0.56199306\",\n \"0.56167954\",\n \"0.5616622\",\n \"0.56149817\",\n \"0.56137586\",\n \"0.5610844\",\n \"0.5607602\",\n \"0.5606704\",\n \"0.56056166\",\n \"0.56049657\",\n \"0.56045663\",\n \"0.5603459\",\n \"0.56000835\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7964266"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4495,"cells":{"query":{"kind":"string","value":"Validate values against the twine schema."},"document":{"kind":"string","value":"def _validate_values(self, kind, source, cls=None, **kwargs):\n data = self._load_json(kind, source, **kwargs)\n self._validate_against_schema(kind, data)\n if cls:\n return cls(**data)\n return data"},"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 validate():","def validate(self, name, values):\r\n \r\n pass","def is_schema_valid(self, schema):\n for k, v in schema.items():\n if v[0] == \"var_len\":\n assert len(v) == 2\n assert v[1] in TF_VALUE\n\n if v[0] == \"fixed_len\":\n assert len(v) == 3\n assert v[1] in TF_VALUE\n assert isinstance(v[2], list)","def validate(cls, data, errors):","def test_validation_function(self):\n\n for data in ('tbldata', 'dihedraldata', 'rdcdata', 'danidata'):\n v = self.web.query_nodes(key=data)\n\n if not v.empty():\n self.assertTrue(validate_tbl(v.value, pcs=False))","def test_match_valid_data_val(self):\n f = lws.valid_data_val\n schema_val = ('some text', str, 'text')\n assert f(schema_val, 'text') is True\n schema_val = ('some number', float, 7.00)\n assert f(schema_val, 7) is False\n assert f(schema_val, 7.00) is True\n schema_val = ('True', bool, True)\n assert f(schema_val, True) is True\n assert f(schema_val, False) is False\n schema_val = ('even', int, lambda x: x % 2 == 0)\n assert f(schema_val, 2) is True\n assert f(schema_val, 257) is False","def _validate_data(self, vms, fw_rules):\n self._validate_vms(vms)\n self._validate_fw_rules(fw_rules)\n self._validated = True","def validate(self, instance, value):","def validate(self, instance, value):","def validate(self):\n for rule in self.get_rules():\n rule.validate(self.get_val())","def check_validity(self):","def check_validity(self):\n try:\n if self.type == ConstraintTypes.EQUAL:\n enforce(\n isinstance(self.value, (int, float, str, bool)),\n f\"Expected one of type in (int, float, str, bool), got {self.value}\",\n )\n elif self.type == ConstraintTypes.NOT_EQUAL:\n enforce(\n isinstance(self.value, (int, float, str, bool)),\n f\"Expected one of type in (int, float, str, bool), got {self.value}\",\n )\n elif self.type == ConstraintTypes.LESS_THAN:\n enforce(\n isinstance(self.value, (int, float, str)),\n f\"Expected one of type in (int, float, str), got {self.value}\",\n )\n elif self.type == ConstraintTypes.LESS_THAN_EQ:\n enforce(\n isinstance(self.value, (int, float, str)),\n f\"Expected one of type in (int, float, str), got {self.value}\",\n )\n elif self.type == ConstraintTypes.GREATER_THAN:\n enforce(\n isinstance(self.value, (int, float, str)),\n f\"Expected one of type in (int, float, str), got {self.value}\",\n )\n elif self.type == ConstraintTypes.GREATER_THAN_EQ:\n enforce(\n isinstance(self.value, (int, float, str)),\n f\"Expected one of type in (int, float, str), got {self.value}\",\n )\n elif self.type == ConstraintTypes.WITHIN:\n enforce(\n isinstance(self.value, (list, tuple)),\n f\"Expected one of type in (list, tuple), got {self.value}\",\n )\n enforce(\n len(self.value) == 2, f\"Expected length=2, got {len(self.value)}\"\n )\n enforce(\n isinstance(self.value[0], type(self.value[1])), \"Invalid types.\"\n )\n enforce(\n isinstance(self.value[1], type(self.value[0])), \"Invalid types.\"\n )\n elif self.type == ConstraintTypes.IN:\n enforce(\n isinstance(self.value, (list, tuple, set)),\n f\"Expected one of type in (list, tuple, set), got {self.value}\",\n )\n if len(self.value) > 0:\n _type = type(next(iter(self.value)))\n enforce(\n all(isinstance(obj, _type) for obj in self.value),\n \"Invalid types.\",\n )\n elif self.type == ConstraintTypes.NOT_IN:\n enforce(\n isinstance(self.value, (list, tuple, set)),\n f\"Expected one of type in (list, tuple, set), got {self.value}\",\n )\n if len(self.value) > 0:\n _type = type(next(iter(self.value)))\n enforce(\n all(isinstance(obj, _type) for obj in self.value),\n \"Invalid types.\",\n )\n elif self.type == ConstraintTypes.DISTANCE:\n enforce(\n isinstance(self.value, (list, tuple)),\n f\"Expected one of type in (list, tuple), got {self.value}\",\n )\n enforce(\n len(self.value) == 2, f\"Expected length=2, got {len(self.value)}\"\n )\n enforce(\n isinstance(self.value[0], Location),\n \"Invalid type, expected Location.\",\n )\n enforce(\n isinstance(self.value[1], float), \"Invalid type, expected Location.\"\n )\n else: # pragma: nocover\n raise ValueError(\"Type not recognized.\")\n except ValueError:\n return False # pragma: nocover\n\n return True","def test_validate_schema():\n data = {\n 'business': {\n 'cacheId': 1,\n 'foundingDate': '2007-04-08T00:00:00+00:00',\n 'identifier': 'CP1234567',\n 'legalName': 'legal name CP1234567'\n },\n }\n\n is_valid, _ = validate(data, 'business', validate_schema=True)\n\n assert is_valid","def validate(self):","def validate(self):","def _validate(self, instance, value):","def validate(self, value, clean=True):\n pass","def validate(self, value, clean=True):\n pass","def validate(self):\n self.valid = True\n\n if self._value is None and self._strict:\n self.valid = False\n raise self.MissingFieldData\n\n elif self._value is not None:\n self._type_specific_validation()","def validate_full_schema(self):\n #self.check_duplicate_labels()\n for record in self.extension_schema['schema']['@graph']:\n #self.check_whether_atid_and_label_match(record)\n if record['@type'] == \"rdfs:Class\":\n self.validate_class_schema(record)\n #self.validate_class_label(record[\"@id\"])\n self.validate_validation_field(record)\n elif record['@type'] == \"rdf:Property\":\n self.validate_property_schema(record)\n #self.validate_property_label(record[\"@id\"])\n #self.validate_domainIncludes_field(record[\"http://schema.org/domainIncludes\"])\n #self.validate_rangeIncludes_field(record[\"http://schema.org/rangeIncludes\"])\n #else:\n # raise ValueError('wrong @type value found: {}'.format(record))","def validate(self, value):\n return True","def validate(self, value):\n\n return True","def test_validate_pincode(self):\n schema = vol.Schema(valid_pin)\n\n for value in ('', '123-456-78', 'a23-45-678', '12345678', 1234):\n with self.assertRaises(vol.MultipleInvalid):\n schema(value)\n\n for value in ('123-45-678', '234-56-789'):\n self.assertTrue(schema(value))","def _validate(self, value):\n return True","def validate_against_schema(request, schema, data):\n try:\n data_pure = schema.deserialize(data)\n data_clean = post_serialize(data_pure)\n # Attach data_clean to request: see usage in views.\n request.data_clean = data_clean\n except Invalid as e:\n # here we transform the errors we got from colander into cornice\n # errors\n for field, error in e.asdict().items():\n request.errors.add('body', field, error)","def __validate():\n # TODO: implement","def _validate_input(self):\n self.data.validate()\n self.meta_hybridizer.validate_input()","def validate_data(self, row, col, value):\n\n return True","def _validate_against_schema(self, strand, data):\n schema = self._get_schema(strand)\n\n try:\n jsonschema_validate(instance=data, schema=schema)\n logger.debug(\"Validated %s against schema\", strand)\n\n except ValidationError as e:\n raise exceptions.invalid_contents_map[strand](str(e))","def validate(self, value):\n if value is None:\n msg = message_factory.get_message('vapi.data.validate.mismatch',\n self.type,\n 'None')\n return [msg]\n return None","def test_multiple_if_pass(self):\n schema = yaml.load(self.yaml_ifif, Loader=yaml.FullLoader)\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\n document = {'age': '21', 'lifestage': 'adult'} # True\n self.assertTrue(val.validate(document))\n\n document = {'age': '2', 'lifestage': 'juvenile'} # True\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\n self.assertTrue(val.validate(document))","def check_valid_schema(context):\n data = context.response.json()\n validate_schema(data)","def validate(self):\n\n raise NotImplementedError('Ando validation is not implemented yet.')","def _validate_values(self, values):\n prev_len = -1\n i = j = -1\n if values is None or len(values) == 0:\n self.shape = 0, 0\n return\n for i, row in enumerate(values):\n if prev_len == -1:\n prev_len = len(row)\n if prev_len != len(row):\n raise ValueError(f\"Row {i} differs in length: {prev_len} != {len(row)}\")\n for j, val in enumerate(row):\n if type(val) not in (int, float, complex):\n raise ValueError(f\"[{i}, {j}]: {val} is of bad type ({type(val)})\")\n if val == 0:\n self.empty_loc = (i, j)\n if i == -1:\n self.shape = 0, 0\n else:\n self.shape = i + 1, j + 1","def validate(self, doc):\n return self.schema.validate(doc)","def validate(self, value):\n if value is None:\n msg = message_factory.get_message('vapi.data.validate.mismatch',\n self.type,\n 'None')\n return [msg]\n\n if value.type != Type.ERROR:\n msg = message_factory.get_message('vapi.data.validate.mismatch',\n self.type,\n value.type)\n return [msg]\n\n return None","def validate(self) -> t.NoReturn:\n try:\n if \"label_columns\" in self.config:\n assert isinstance(self.config.label_columns, list), (\n \"label_columns\",\n list,\n type(self.config.label_columns),\n )\n for elem in self.config.label_columns:\n assert isinstance(elem, int), (\"label_columns element\", int, type(elem))\n assert elem >= 0, \"label_columns element negative\"\n if \"options\" in self.config:\n assert isinstance(self.config.options, (dict, AttributeDict)), (\n \"Options\",\n (dict, AttributeDict),\n type(self.config.options),\n )\n except AssertionError as e:\n raise MisconfiguredError(\"timevalue: {} expected {}, got: {}\".format(*e.args[0]))","def validate(self):\n self._validate_time_index()\n self._validate_num_profiles()\n self._validate_merge_col_exists()\n self._validate_unique_merge_col()\n self._validate_merge_col_overlaps()","def test_validate_business_schema():\n data = {\n 'business': {\n 'cacheId': 1,\n 'foundingDate': '2007-04-08T00:00:00+00:00',\n 'identifier': 'CP1234567',\n 'lastLedgerTimestamp': '2019-04-15T20:05:49.068272+00:00',\n 'lastPreBobFilingTimestamp': '2019-04-15T20:05:49.068272+00:00',\n 'legalName': 'legal name - CP1234567'\n },\n }\n\n is_valid, _ = validate(data, 'business', validate_schema=True)\n\n assert is_valid","def test_multiple_if_error(self):\n schema = yaml.load(self.yaml_ifif, Loader=yaml.FullLoader)\n document = {'age': '21', 'lifestage': 'juvenile'}\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\n val.validate(document)\n self.assertEqual(val.errors,\n {'lifestage': [{'if_0': ['unallowed value juvenile',\n 'max length is 6'],\n 'if_2': ['max length is 5']}]})","def _validate(self):\n pass","def validate(self):\n pass","def validate(self):\n pass","def validate(self):\n pass","def validate(self):\n pass","def validate(self):\n pass","def validate(self):\n pass","def validate(self):\n pass","def validate(self):\n pass","def validate(self) -> None:\n\n if self.field not in self.model.table_fields:\n raise ValueError(f\"Value field {self.field} not present in {self.model.table}\")\n\n if self.pivot:\n if self.pivot not in self.model.table_fields:\n raise ValueError(\n f\"Pivot field {self.pivot} not present in {self.model.table}\"\n )\n\n if self.connector:\n if self.connector not in self.model.table_fields:\n raise ValueError(\n f\"Connector field {self.connector} not present in {self.model.table}\"\n )\n\n for field in self.selectors:\n if field not in self.model.table_fields:\n raise ValueError(f\"Selector field {field} not present in {self.model.table}\")","def validate_fields(self, window, values):\n \n #Check if record id is new\n is_valid = True\n problem_field_name = \"\"\n experiment_names = GUI.api.get_experiment_names()\n if values['record_id'] in experiment_names:\n is_valid = False\n problem_field_name = \"Record ID\"\n return is_valid, problem_field_name \n \n metadata = GUI.api.get_metadata()\n enbaled_fields = filter(lambda elem: (elem['form_name']=='material_information' or elem['form_name']=='printer_information') \n and not (isinstance(window[elem['field_name']], sg.Text) or window[elem['field_name']].Disabled), metadata)#only validate enbaled fields\n for field in enbaled_fields:\n validation = field['text_validation_type_or_show_slider_number']\n value = values[field['field_name']]\n if (validation == \"number\" and value.isdigit()):\n #check if correct ranges\n if field['text_validation_max'] != \"\":\n if value > field['text_validation_max']:\n is_valid = False \n problem_field_name = field['field_label']\n return is_valid, problem_field_name \n if field['text_validation_min'] != \"\":\n if value < field['text_validation_min']:\n is_valid = False \n problem_field_name = field['field_label']\n return is_valid, problem_field_name \n elif (validation == \"number\" and not value.isdigit()):\n is_valid = False\n problem_field_name = field['field_label']\n return is_valid, problem_field_name\n return is_valid, problem_field_name","def test_required_term(self):\n schema = yaml.load(self.yaml_multiple_term, Loader=yaml.FullLoader)\n\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\n document = {'abundance': 'many'}\n val.validate(document)\n self.assertEqual(val.errors, {'eventDate': ['required field']})","def isValidForSchema(schema):\n\n return True","def test_validation_class(self):\n\n for data in ('tbldata', 'dihedraldata', 'rdcdata', 'danidata', 'tensordata', 'pcsdata'):\n v = self.web.query_nodes(key=data)\n\n if not v.empty():\n self.assertTrue(v.validate())","def check_validity(self):\n if len(self.constraints) < 2: # pragma: nocover\n raise ValueError(\n \"Invalid input value for type '{}': number of \"\n \"subexpression must be at least 2.\".format(type(self).__name__)\n )\n for constraint in self.constraints:\n constraint.check_validity()","def check_validity(self):\n if len(self.constraints) < 2: # pragma: nocover\n raise ValueError(\n \"Invalid input value for type '{}': number of \"\n \"subexpression must be at least 2.\".format(type(self).__name__)\n )\n for constraint in self.constraints:\n constraint.check_validity()","def validate(self, schema=None, callback=None):\n return hxl.schema(schema, callback).validate(self)","def validate(self):\n self._check_type()","def test_is_valid_invalid_resume(self):\n self.assertFalse(resumeschema.is_valid(self.invalid_resume))","def test__validate_topic__2():\n for input_value in (\n 12.6,\n ):\n with vampytest.assert_raises(TypeError):\n validate_topic(input_value)","def validate(self,value):\r\n return type(value) is self.datatype","def test_conversion_schema():\n legal_filing = {'conversion': BEN_CONVERSION}\n is_valid, errors = validate(legal_filing, 'conversion')\n\n if errors:\n for err in errors:\n print(err.message)\n print(errors)\n\n assert is_valid","def validate(self):\n ...","def test_validate_ok(self, args, value):\n sch = scheme.Scheme(*args)\n sch.validate(value)","def validate(self, value, obj=None):\n return True","def _validate_row(self, row):\n\n # assume value.\n is_valid = True\n\n # test if each field in @row has the correct data type.\n tests = []\n for field, value in row.items():\n value_type, header_type = (type(value).__name__, \n self.required_headers[field].__name__)\n test = value_type == header_type\n if not test:\n err = \"Field '{}' not valid; expected '{}', got '{}'.\".format(field,\n header_type, value_type)\n self.logger.debug(err)\n tests.append(test)\n\n # if any test failed, set @is_valid to False.\n if False in tests:\n is_valid = False\n \n return is_valid","def check_data(self):\n\n for i in range(len(self.full_ed_lines)):\n if self.full_ed_lines[i].text() != \"\":\n if self.full_ed_lines[i].hasAcceptableInput():\n continue\n else:\n if i == 1:\n self.msg2Statusbar.emit('Неправильный формат версии! Исправьте и повторите действие!')\n elif i == 5:\n self.msg2Statusbar.emit('Неправильная почта! Исправьте и повторите действие!')\n return False\n else:\n self.msg2Statusbar.emit('Не все поля заполнены! Исправьте и повторите действие!')\n return False\n return True","def validate_input(self):\n self._validate_limits_cols_prefixed()\n self._validate_fillna_cols_prefixed()\n self._validate_ratio_input()","def test_not_blank_validator_valid_value_should_return_true(self):\n for item in self.stdtype_fixtures:\n self.assertTrue(NotBlankValidator(TypeHint(item.get('type')), item.get('valid')))","def _validate_input(self):\n\n try:\n expected_type(str, self.venue_id, \"venue_id\")\n expected_type(datetime.datetime, self.timestamp_utc, \"timestamp_utc\")\n\n expected_type(VenueStreamType, self.measurement_type, \"measurement_type\")\n\n expected_type(int, self.number_of_people, \"number_of_people\")\n\n if self.measurement_type is VenueStreamType.ABSOLUTE:\n if self.operator:\n raise ValueError(\"The stream type for the venue doesn't allow passing an Event operator\")\n\n elif self.measurement_type is VenueStreamType.EVENT:\n expected_type(EventStreamOperator, self.operator, \"operator\")\n else:\n raise ValueError(\"Unsupported member of the VenueStreamType enum\")\n\n if self.metadata:\n expected_type(dict, self.metadata, \"metadata\")\n\n except Exception as ex:\n raise ValueError(\"Validation of input failed. Reason: %s\" % str(ex))","def validate_data(self, deployment='ops'):\n self.validator.set_example(self.example)\n\n # Don't just use the built in validate_data method as this needs to be future proofed against C100 firmware\n # upgrades. This upgrade will result in a new mode SELAP (R...CNTL2MODE == 64).\n self.validator.validate_capture_file_counts()\n self.validator.validate_capture_file_waveforms()\n\n # Many of these examples will have some amount of rounding error.\n self.validator.validate_waveform_times(min_end=10.0, max_start=-1534.0, step_size=0.2)\n self.validator.validate_cavity_modes(mode=(4, 64), deployment=deployment)\n self.validator.validate_zones()","def validate(self):\n try:\n self.values.clear()\n self.values.append(int(self.e1.get()))\n except ValueError:\n messagebox.showwarning(\n \"Bad input\",\n \"Illegal values, please try again.\")\n return False\n\n return True","def test__validate_owner__1():\n for field_value in (\n 12.6,\n ):\n with vampytest.assert_raises(TypeError):\n validate_owner(field_value)","def validate_data(values):\n try:\n [int(value) for value in values]\n if len(values) != 6:\n raise ValueError(\n f'Exactly 6 values are required - you provided {len(values)}'\n )\n except ValueError as e:\n print(f'Invalid data entered: {e}, please try again!\\n')\n return False\n\n return True","def check_value(self, value):","def is_valid(self, value):\r\n pass","def validate(self, value: Any, low: int, high: int) -> bool:\n pass","def _further_validate_and_setup(self) -> None:\n\n # Make sure parameters make sense/are valid\n if len(self.validated['learners']) != len(self.validated['param_grids']):\n raise SchemaError(autos=None,\n errors='The lists of of learners and parameter '\n 'grids must be the same size.')\n if (self.validated['hashed_features'] is not None\n and self.validated['hashed_features'] == 0):\n self.validated['hashed_features'] = self._n_features_feature_hashing\n if self.validated['lognormal'] and self.validated['power_transform']:\n raise SchemaError(autos=None,\n errors='Both \"lognormal\" and \"power_transform\" '\n 'were set simultaneously.')\n if len(self.validated['learners']) != len(self.validated['param_grids']):\n raise SchemaError(autos=None,\n errors='The \"learners\" and \"param_grids\" '\n 'parameters were both set and the '\n 'lengths of the lists are unequal.')","def test_admin_freeze_schema():\n legal_filing = {'adminFreeze': ADMIN_FREEZE}\n\n is_valid, errors = validate(legal_filing, 'admin_freeze')\n\n if errors:\n for err in errors:\n print(err.message)\n print(errors)\n\n assert is_valid","def validate(cls, value):\n return cls.properties.validate(value)","def validate(entry: _LexiconEntry) -> None:\n _entry_has_required_fields(entry)\n _entry_field_values_are_not_empty(entry)\n _entry_field_values_does_not_contain_infix_whitespace(entry)\n _entry_tag_is_valid(entry)\n _entry_compound_annotation_is_valid(entry)\n _entry_morphophonemics_annotation_is_valid(entry)\n _entry_features_annotation_is_valid(entry)\n _entry_has_required_features(entry)\n _entry_required_features_are_valid(entry)\n _entry_optional_features_are_valid(entry)\n _entry_features_are_not_redundant(entry)","def testValid(self):\n validate = timing_util.ValidateMeasurementsFlag\n self.assertIs(validate([]), True)\n self.assertIs(validate(['none']), True)\n self.assertIs(validate(['end_to_end_runtime']), True)\n self.assertIs(validate(['runtimes']), True)\n self.assertIs(validate(['timestamps']), True)\n self.assertIs(validate(['end_to_end_runtime', 'runtimes']), True)\n self.assertIs(validate(['end_to_end_runtime', 'timestamps']), True)\n self.assertIs(validate(['runtimes', 'timestamps']), True)\n self.assertIs(\n validate(['end_to_end_runtime', 'runtimes', 'timestamps']), True)","def validate(self, list_value):\n errors = DataDefinition.validate(self, list_value)\n if errors:\n return errors\n\n for index, value in enumerate(list_value):\n errors = self.element_type.validate(value)\n if errors:\n msg = message_factory.get_message(\n 'vapi.data.list.invalid.entry',\n str(value), index)\n return [msg] + errors\n\n return None","def validate(self):\r\n for name in self._columns.keys():\r\n func_name = 'validate_{}'.format(name)\r\n val = getattr(self, name)\r\n if hasattr(self, func_name):\r\n val = getattr(self, func_name)(val)\r\n else:\r\n val = self.validate_field(name, val)\r\n setattr(self, name, val)","def test_oneOf_and_anyOf_are_weak_matches(self):\r\n\r\n validator = Draft4Validator(\r\n {\r\n \"minProperties\" : 2,\r\n \"anyOf\" : [{\"type\" : \"string\"}, {\"type\" : \"number\"}],\r\n \"oneOf\" : [{\"type\" : \"string\"}, {\"type\" : \"number\"}],\r\n }\r\n )\r\n best = self.best_match(validator.iter_errors({}))\r\n self.assertEqual(best.validator, \"minProperties\")","def test_validate_valid_resume(self):\n # DEV: `validate` will raise an exception if it could not validate\n self.assertIsNone(resumeschema.validate(self.valid_resume))","def validate(self, converted_value, context):\n pass","def test_firms_conversion_schema():\n legal_filing = {'conversion': FIRMS_CONVERSION}\n\n is_valid, errors = validate(legal_filing, 'conversion')\n\n if errors:\n for err in errors:\n print(err.message)\n print(errors)\n\n assert is_valid","def test_Validator_is_valid_two_arguments(self):\n\n validator = validators.Draft7Validator({})\n with self.assertWarns(DeprecationWarning) as w:\n result = validator.is_valid(\"foo\", {\"type\": \"number\"})\n\n self.assertFalse(result)\n self.assertEqual(w.filename, __file__)\n self.assertTrue(\n str(w.warning).startswith(\n \"Passing a schema to Validator.is_valid is deprecated \",\n ),\n )","def validate(self, value):\n # Use the parent's handling of required fields, etc.\n super().validate(value)\n for email in value:\n validate_email(email)","def verify_post_data ( ):\n # check every field is present\n try:\n request.json[ 'source_lang' ]\n request.json[ 'target_lang' ]\n request.json[ 'text' ]\n\n TranslatorApp.verify_rpc_value ( request.json )\n\n except KeyError: # All the values are not present\n # 400 Bad Request\n abort ( 400, \"All mandatory fields are not provided\" )\n except ValueError as err:\n # 422 Unprocessable Entity\n abort ( 422, \"Unprocessable value: {0}\".format ( err.args ) )\n except BadRequest:\n # 400 Bad Request\n abort ( 400, \"Provided values are having malformed syntax\" )","def _validate(self):\n schema_version = util.schemas[self.schema_name]\n stored_schemas = util.stored_schemas\n\n try:\n schema_obj = stored_schemas[\n \"http://redfish.dmtf.org/schemas/v1/\" + schema_version]\n except KeyError:\n raise OneViewRedfishError(\"{} not found\".format(schema_version))\n\n resolver = jsonschema.RefResolver('', schema_obj, store=stored_schemas)\n jsonschema.validate(self.redfish, schema_obj, resolver=resolver)","def validate_values(self):\n if self.avp_def.has_defined_values():\n defined_values = dict(self.avp_def.attr_defined_values)\n if self.avp_value not in defined_values.values():\n raise ValueError(\n f\"{self.avp_def.attr_name} - value {self.avp_value} \"\n \"is not allowed\")\n\n return True","def test__validate_status__1():\n for input_value in (\n 12.6,\n ):\n with vampytest.assert_raises(TypeError):\n validate_status(input_value)","def _check_validity(self):\n pass","def validate(self, data):\n l = len(data[\"start_times\"])\n for i in range(l):\n if data[\"start_times\"][i]>=data['end_times'][i]:\n raise serializers.ValidationError(\"Start times should come before end times\") \n return data","def check_consistency(self) -> 'Schema':\n errors = []\n fields = self.__fields__\n for k, v in fields.items():\n _, err = v.validate(getattr(self, k), fields, loc=k)\n if err:\n errors.append(err)\n if errors:\n raise ValidationError(errors, self.__class__)\n return self","def test_minmax(self):\n val = DwcaValidator(yaml.load(self.yaml_value, Loader=yaml.FullLoader),\n error_handler=WhipErrorHandler)\n document = {'percentage': 9.}\n self.assertFalse(val.validate(document))\n document = {'percentage': 2.1}\n self.assertFalse(val.validate(document))\n\n val = DwcaValidator(yaml.load(self.yaml_value, Loader=yaml.FullLoader),\n error_handler=WhipErrorHandler)\n document = {'individualCount': 9}\n self.assertFalse(val.validate(document))\n document = {'individualCount': 2}\n self.assertFalse(val.validate(document))","def test_special_case(self):\n cases = [\n ('3467875434578764345789654', False),\n ('AAAAAAAAAAA', False),\n ('', False),\n ]\n for titulo_eleitoral, is_valid in cases:\n self.assertEqual(self.titulo_eleitoral.validate(titulo_eleitoral), is_valid)","def validate(self, test_data):\n if not isinstance(test_data, np.number):\n raise ValidationError('Invalid type/value.', 'numpy.number',\n type(test_data))\n if self.max_value is not None and test_data > self.max_value:\n raise ValidationError('Maximum value exceeded.',\n self.max_value, test_data)\n if self.min_value is not None and test_data < self.min_value:\n raise ValidationError('Minimum value undercut.',\n self.min_value, test_data)\n if test_data.dtype != self.dtype:\n raise ValidationError('Invalid dtype.', self.dtype,\n test_data.dtype)","def validate_subset_of_schema(self, schema):\n super(BooleanAttributeSchema, self).validate_subset_of_schema(schema)\n\n if not self.values.issubset(schema.values):\n raise AttributeSchemaError(\n \"Values %s are not a subset of %s\"\n % (self.values, schema.values)\n )"],"string":"[\n \"def validate():\",\n \"def validate(self, name, values):\\r\\n \\r\\n pass\",\n \"def is_schema_valid(self, schema):\\n for k, v in schema.items():\\n if v[0] == \\\"var_len\\\":\\n assert len(v) == 2\\n assert v[1] in TF_VALUE\\n\\n if v[0] == \\\"fixed_len\\\":\\n assert len(v) == 3\\n assert v[1] in TF_VALUE\\n assert isinstance(v[2], list)\",\n \"def validate(cls, data, errors):\",\n \"def test_validation_function(self):\\n\\n for data in ('tbldata', 'dihedraldata', 'rdcdata', 'danidata'):\\n v = self.web.query_nodes(key=data)\\n\\n if not v.empty():\\n self.assertTrue(validate_tbl(v.value, pcs=False))\",\n \"def test_match_valid_data_val(self):\\n f = lws.valid_data_val\\n schema_val = ('some text', str, 'text')\\n assert f(schema_val, 'text') is True\\n schema_val = ('some number', float, 7.00)\\n assert f(schema_val, 7) is False\\n assert f(schema_val, 7.00) is True\\n schema_val = ('True', bool, True)\\n assert f(schema_val, True) is True\\n assert f(schema_val, False) is False\\n schema_val = ('even', int, lambda x: x % 2 == 0)\\n assert f(schema_val, 2) is True\\n assert f(schema_val, 257) is False\",\n \"def _validate_data(self, vms, fw_rules):\\n self._validate_vms(vms)\\n self._validate_fw_rules(fw_rules)\\n self._validated = True\",\n \"def validate(self, instance, value):\",\n \"def validate(self, instance, value):\",\n \"def validate(self):\\n for rule in self.get_rules():\\n rule.validate(self.get_val())\",\n \"def check_validity(self):\",\n \"def check_validity(self):\\n try:\\n if self.type == ConstraintTypes.EQUAL:\\n enforce(\\n isinstance(self.value, (int, float, str, bool)),\\n f\\\"Expected one of type in (int, float, str, bool), got {self.value}\\\",\\n )\\n elif self.type == ConstraintTypes.NOT_EQUAL:\\n enforce(\\n isinstance(self.value, (int, float, str, bool)),\\n f\\\"Expected one of type in (int, float, str, bool), got {self.value}\\\",\\n )\\n elif self.type == ConstraintTypes.LESS_THAN:\\n enforce(\\n isinstance(self.value, (int, float, str)),\\n f\\\"Expected one of type in (int, float, str), got {self.value}\\\",\\n )\\n elif self.type == ConstraintTypes.LESS_THAN_EQ:\\n enforce(\\n isinstance(self.value, (int, float, str)),\\n f\\\"Expected one of type in (int, float, str), got {self.value}\\\",\\n )\\n elif self.type == ConstraintTypes.GREATER_THAN:\\n enforce(\\n isinstance(self.value, (int, float, str)),\\n f\\\"Expected one of type in (int, float, str), got {self.value}\\\",\\n )\\n elif self.type == ConstraintTypes.GREATER_THAN_EQ:\\n enforce(\\n isinstance(self.value, (int, float, str)),\\n f\\\"Expected one of type in (int, float, str), got {self.value}\\\",\\n )\\n elif self.type == ConstraintTypes.WITHIN:\\n enforce(\\n isinstance(self.value, (list, tuple)),\\n f\\\"Expected one of type in (list, tuple), got {self.value}\\\",\\n )\\n enforce(\\n len(self.value) == 2, f\\\"Expected length=2, got {len(self.value)}\\\"\\n )\\n enforce(\\n isinstance(self.value[0], type(self.value[1])), \\\"Invalid types.\\\"\\n )\\n enforce(\\n isinstance(self.value[1], type(self.value[0])), \\\"Invalid types.\\\"\\n )\\n elif self.type == ConstraintTypes.IN:\\n enforce(\\n isinstance(self.value, (list, tuple, set)),\\n f\\\"Expected one of type in (list, tuple, set), got {self.value}\\\",\\n )\\n if len(self.value) > 0:\\n _type = type(next(iter(self.value)))\\n enforce(\\n all(isinstance(obj, _type) for obj in self.value),\\n \\\"Invalid types.\\\",\\n )\\n elif self.type == ConstraintTypes.NOT_IN:\\n enforce(\\n isinstance(self.value, (list, tuple, set)),\\n f\\\"Expected one of type in (list, tuple, set), got {self.value}\\\",\\n )\\n if len(self.value) > 0:\\n _type = type(next(iter(self.value)))\\n enforce(\\n all(isinstance(obj, _type) for obj in self.value),\\n \\\"Invalid types.\\\",\\n )\\n elif self.type == ConstraintTypes.DISTANCE:\\n enforce(\\n isinstance(self.value, (list, tuple)),\\n f\\\"Expected one of type in (list, tuple), got {self.value}\\\",\\n )\\n enforce(\\n len(self.value) == 2, f\\\"Expected length=2, got {len(self.value)}\\\"\\n )\\n enforce(\\n isinstance(self.value[0], Location),\\n \\\"Invalid type, expected Location.\\\",\\n )\\n enforce(\\n isinstance(self.value[1], float), \\\"Invalid type, expected Location.\\\"\\n )\\n else: # pragma: nocover\\n raise ValueError(\\\"Type not recognized.\\\")\\n except ValueError:\\n return False # pragma: nocover\\n\\n return True\",\n \"def test_validate_schema():\\n data = {\\n 'business': {\\n 'cacheId': 1,\\n 'foundingDate': '2007-04-08T00:00:00+00:00',\\n 'identifier': 'CP1234567',\\n 'legalName': 'legal name CP1234567'\\n },\\n }\\n\\n is_valid, _ = validate(data, 'business', validate_schema=True)\\n\\n assert is_valid\",\n \"def validate(self):\",\n \"def validate(self):\",\n \"def _validate(self, instance, value):\",\n \"def validate(self, value, clean=True):\\n pass\",\n \"def validate(self, value, clean=True):\\n pass\",\n \"def validate(self):\\n self.valid = True\\n\\n if self._value is None and self._strict:\\n self.valid = False\\n raise self.MissingFieldData\\n\\n elif self._value is not None:\\n self._type_specific_validation()\",\n \"def validate_full_schema(self):\\n #self.check_duplicate_labels()\\n for record in self.extension_schema['schema']['@graph']:\\n #self.check_whether_atid_and_label_match(record)\\n if record['@type'] == \\\"rdfs:Class\\\":\\n self.validate_class_schema(record)\\n #self.validate_class_label(record[\\\"@id\\\"])\\n self.validate_validation_field(record)\\n elif record['@type'] == \\\"rdf:Property\\\":\\n self.validate_property_schema(record)\\n #self.validate_property_label(record[\\\"@id\\\"])\\n #self.validate_domainIncludes_field(record[\\\"http://schema.org/domainIncludes\\\"])\\n #self.validate_rangeIncludes_field(record[\\\"http://schema.org/rangeIncludes\\\"])\\n #else:\\n # raise ValueError('wrong @type value found: {}'.format(record))\",\n \"def validate(self, value):\\n return True\",\n \"def validate(self, value):\\n\\n return True\",\n \"def test_validate_pincode(self):\\n schema = vol.Schema(valid_pin)\\n\\n for value in ('', '123-456-78', 'a23-45-678', '12345678', 1234):\\n with self.assertRaises(vol.MultipleInvalid):\\n schema(value)\\n\\n for value in ('123-45-678', '234-56-789'):\\n self.assertTrue(schema(value))\",\n \"def _validate(self, value):\\n return True\",\n \"def validate_against_schema(request, schema, data):\\n try:\\n data_pure = schema.deserialize(data)\\n data_clean = post_serialize(data_pure)\\n # Attach data_clean to request: see usage in views.\\n request.data_clean = data_clean\\n except Invalid as e:\\n # here we transform the errors we got from colander into cornice\\n # errors\\n for field, error in e.asdict().items():\\n request.errors.add('body', field, error)\",\n \"def __validate():\\n # TODO: implement\",\n \"def _validate_input(self):\\n self.data.validate()\\n self.meta_hybridizer.validate_input()\",\n \"def validate_data(self, row, col, value):\\n\\n return True\",\n \"def _validate_against_schema(self, strand, data):\\n schema = self._get_schema(strand)\\n\\n try:\\n jsonschema_validate(instance=data, schema=schema)\\n logger.debug(\\\"Validated %s against schema\\\", strand)\\n\\n except ValidationError as e:\\n raise exceptions.invalid_contents_map[strand](str(e))\",\n \"def validate(self, value):\\n if value is None:\\n msg = message_factory.get_message('vapi.data.validate.mismatch',\\n self.type,\\n 'None')\\n return [msg]\\n return None\",\n \"def test_multiple_if_pass(self):\\n schema = yaml.load(self.yaml_ifif, Loader=yaml.FullLoader)\\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\\n document = {'age': '21', 'lifestage': 'adult'} # True\\n self.assertTrue(val.validate(document))\\n\\n document = {'age': '2', 'lifestage': 'juvenile'} # True\\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\\n self.assertTrue(val.validate(document))\",\n \"def check_valid_schema(context):\\n data = context.response.json()\\n validate_schema(data)\",\n \"def validate(self):\\n\\n raise NotImplementedError('Ando validation is not implemented yet.')\",\n \"def _validate_values(self, values):\\n prev_len = -1\\n i = j = -1\\n if values is None or len(values) == 0:\\n self.shape = 0, 0\\n return\\n for i, row in enumerate(values):\\n if prev_len == -1:\\n prev_len = len(row)\\n if prev_len != len(row):\\n raise ValueError(f\\\"Row {i} differs in length: {prev_len} != {len(row)}\\\")\\n for j, val in enumerate(row):\\n if type(val) not in (int, float, complex):\\n raise ValueError(f\\\"[{i}, {j}]: {val} is of bad type ({type(val)})\\\")\\n if val == 0:\\n self.empty_loc = (i, j)\\n if i == -1:\\n self.shape = 0, 0\\n else:\\n self.shape = i + 1, j + 1\",\n \"def validate(self, doc):\\n return self.schema.validate(doc)\",\n \"def validate(self, value):\\n if value is None:\\n msg = message_factory.get_message('vapi.data.validate.mismatch',\\n self.type,\\n 'None')\\n return [msg]\\n\\n if value.type != Type.ERROR:\\n msg = message_factory.get_message('vapi.data.validate.mismatch',\\n self.type,\\n value.type)\\n return [msg]\\n\\n return None\",\n \"def validate(self) -> t.NoReturn:\\n try:\\n if \\\"label_columns\\\" in self.config:\\n assert isinstance(self.config.label_columns, list), (\\n \\\"label_columns\\\",\\n list,\\n type(self.config.label_columns),\\n )\\n for elem in self.config.label_columns:\\n assert isinstance(elem, int), (\\\"label_columns element\\\", int, type(elem))\\n assert elem >= 0, \\\"label_columns element negative\\\"\\n if \\\"options\\\" in self.config:\\n assert isinstance(self.config.options, (dict, AttributeDict)), (\\n \\\"Options\\\",\\n (dict, AttributeDict),\\n type(self.config.options),\\n )\\n except AssertionError as e:\\n raise MisconfiguredError(\\\"timevalue: {} expected {}, got: {}\\\".format(*e.args[0]))\",\n \"def validate(self):\\n self._validate_time_index()\\n self._validate_num_profiles()\\n self._validate_merge_col_exists()\\n self._validate_unique_merge_col()\\n self._validate_merge_col_overlaps()\",\n \"def test_validate_business_schema():\\n data = {\\n 'business': {\\n 'cacheId': 1,\\n 'foundingDate': '2007-04-08T00:00:00+00:00',\\n 'identifier': 'CP1234567',\\n 'lastLedgerTimestamp': '2019-04-15T20:05:49.068272+00:00',\\n 'lastPreBobFilingTimestamp': '2019-04-15T20:05:49.068272+00:00',\\n 'legalName': 'legal name - CP1234567'\\n },\\n }\\n\\n is_valid, _ = validate(data, 'business', validate_schema=True)\\n\\n assert is_valid\",\n \"def test_multiple_if_error(self):\\n schema = yaml.load(self.yaml_ifif, Loader=yaml.FullLoader)\\n document = {'age': '21', 'lifestage': 'juvenile'}\\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\\n val.validate(document)\\n self.assertEqual(val.errors,\\n {'lifestage': [{'if_0': ['unallowed value juvenile',\\n 'max length is 6'],\\n 'if_2': ['max length is 5']}]})\",\n \"def _validate(self):\\n pass\",\n \"def validate(self):\\n pass\",\n \"def validate(self):\\n pass\",\n \"def validate(self):\\n pass\",\n \"def validate(self):\\n pass\",\n \"def validate(self):\\n pass\",\n \"def validate(self):\\n pass\",\n \"def validate(self):\\n pass\",\n \"def validate(self):\\n pass\",\n \"def validate(self) -> None:\\n\\n if self.field not in self.model.table_fields:\\n raise ValueError(f\\\"Value field {self.field} not present in {self.model.table}\\\")\\n\\n if self.pivot:\\n if self.pivot not in self.model.table_fields:\\n raise ValueError(\\n f\\\"Pivot field {self.pivot} not present in {self.model.table}\\\"\\n )\\n\\n if self.connector:\\n if self.connector not in self.model.table_fields:\\n raise ValueError(\\n f\\\"Connector field {self.connector} not present in {self.model.table}\\\"\\n )\\n\\n for field in self.selectors:\\n if field not in self.model.table_fields:\\n raise ValueError(f\\\"Selector field {field} not present in {self.model.table}\\\")\",\n \"def validate_fields(self, window, values):\\n \\n #Check if record id is new\\n is_valid = True\\n problem_field_name = \\\"\\\"\\n experiment_names = GUI.api.get_experiment_names()\\n if values['record_id'] in experiment_names:\\n is_valid = False\\n problem_field_name = \\\"Record ID\\\"\\n return is_valid, problem_field_name \\n \\n metadata = GUI.api.get_metadata()\\n enbaled_fields = filter(lambda elem: (elem['form_name']=='material_information' or elem['form_name']=='printer_information') \\n and not (isinstance(window[elem['field_name']], sg.Text) or window[elem['field_name']].Disabled), metadata)#only validate enbaled fields\\n for field in enbaled_fields:\\n validation = field['text_validation_type_or_show_slider_number']\\n value = values[field['field_name']]\\n if (validation == \\\"number\\\" and value.isdigit()):\\n #check if correct ranges\\n if field['text_validation_max'] != \\\"\\\":\\n if value > field['text_validation_max']:\\n is_valid = False \\n problem_field_name = field['field_label']\\n return is_valid, problem_field_name \\n if field['text_validation_min'] != \\\"\\\":\\n if value < field['text_validation_min']:\\n is_valid = False \\n problem_field_name = field['field_label']\\n return is_valid, problem_field_name \\n elif (validation == \\\"number\\\" and not value.isdigit()):\\n is_valid = False\\n problem_field_name = field['field_label']\\n return is_valid, problem_field_name\\n return is_valid, problem_field_name\",\n \"def test_required_term(self):\\n schema = yaml.load(self.yaml_multiple_term, Loader=yaml.FullLoader)\\n\\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\\n document = {'abundance': 'many'}\\n val.validate(document)\\n self.assertEqual(val.errors, {'eventDate': ['required field']})\",\n \"def isValidForSchema(schema):\\n\\n return True\",\n \"def test_validation_class(self):\\n\\n for data in ('tbldata', 'dihedraldata', 'rdcdata', 'danidata', 'tensordata', 'pcsdata'):\\n v = self.web.query_nodes(key=data)\\n\\n if not v.empty():\\n self.assertTrue(v.validate())\",\n \"def check_validity(self):\\n if len(self.constraints) < 2: # pragma: nocover\\n raise ValueError(\\n \\\"Invalid input value for type '{}': number of \\\"\\n \\\"subexpression must be at least 2.\\\".format(type(self).__name__)\\n )\\n for constraint in self.constraints:\\n constraint.check_validity()\",\n \"def check_validity(self):\\n if len(self.constraints) < 2: # pragma: nocover\\n raise ValueError(\\n \\\"Invalid input value for type '{}': number of \\\"\\n \\\"subexpression must be at least 2.\\\".format(type(self).__name__)\\n )\\n for constraint in self.constraints:\\n constraint.check_validity()\",\n \"def validate(self, schema=None, callback=None):\\n return hxl.schema(schema, callback).validate(self)\",\n \"def validate(self):\\n self._check_type()\",\n \"def test_is_valid_invalid_resume(self):\\n self.assertFalse(resumeschema.is_valid(self.invalid_resume))\",\n \"def test__validate_topic__2():\\n for input_value in (\\n 12.6,\\n ):\\n with vampytest.assert_raises(TypeError):\\n validate_topic(input_value)\",\n \"def validate(self,value):\\r\\n return type(value) is self.datatype\",\n \"def test_conversion_schema():\\n legal_filing = {'conversion': BEN_CONVERSION}\\n is_valid, errors = validate(legal_filing, 'conversion')\\n\\n if errors:\\n for err in errors:\\n print(err.message)\\n print(errors)\\n\\n assert is_valid\",\n \"def validate(self):\\n ...\",\n \"def test_validate_ok(self, args, value):\\n sch = scheme.Scheme(*args)\\n sch.validate(value)\",\n \"def validate(self, value, obj=None):\\n return True\",\n \"def _validate_row(self, row):\\n\\n # assume value.\\n is_valid = True\\n\\n # test if each field in @row has the correct data type.\\n tests = []\\n for field, value in row.items():\\n value_type, header_type = (type(value).__name__, \\n self.required_headers[field].__name__)\\n test = value_type == header_type\\n if not test:\\n err = \\\"Field '{}' not valid; expected '{}', got '{}'.\\\".format(field,\\n header_type, value_type)\\n self.logger.debug(err)\\n tests.append(test)\\n\\n # if any test failed, set @is_valid to False.\\n if False in tests:\\n is_valid = False\\n \\n return is_valid\",\n \"def check_data(self):\\n\\n for i in range(len(self.full_ed_lines)):\\n if self.full_ed_lines[i].text() != \\\"\\\":\\n if self.full_ed_lines[i].hasAcceptableInput():\\n continue\\n else:\\n if i == 1:\\n self.msg2Statusbar.emit('Неправильный формат версии! Исправьте и повторите действие!')\\n elif i == 5:\\n self.msg2Statusbar.emit('Неправильная почта! Исправьте и повторите действие!')\\n return False\\n else:\\n self.msg2Statusbar.emit('Не все поля заполнены! Исправьте и повторите действие!')\\n return False\\n return True\",\n \"def validate_input(self):\\n self._validate_limits_cols_prefixed()\\n self._validate_fillna_cols_prefixed()\\n self._validate_ratio_input()\",\n \"def test_not_blank_validator_valid_value_should_return_true(self):\\n for item in self.stdtype_fixtures:\\n self.assertTrue(NotBlankValidator(TypeHint(item.get('type')), item.get('valid')))\",\n \"def _validate_input(self):\\n\\n try:\\n expected_type(str, self.venue_id, \\\"venue_id\\\")\\n expected_type(datetime.datetime, self.timestamp_utc, \\\"timestamp_utc\\\")\\n\\n expected_type(VenueStreamType, self.measurement_type, \\\"measurement_type\\\")\\n\\n expected_type(int, self.number_of_people, \\\"number_of_people\\\")\\n\\n if self.measurement_type is VenueStreamType.ABSOLUTE:\\n if self.operator:\\n raise ValueError(\\\"The stream type for the venue doesn't allow passing an Event operator\\\")\\n\\n elif self.measurement_type is VenueStreamType.EVENT:\\n expected_type(EventStreamOperator, self.operator, \\\"operator\\\")\\n else:\\n raise ValueError(\\\"Unsupported member of the VenueStreamType enum\\\")\\n\\n if self.metadata:\\n expected_type(dict, self.metadata, \\\"metadata\\\")\\n\\n except Exception as ex:\\n raise ValueError(\\\"Validation of input failed. Reason: %s\\\" % str(ex))\",\n \"def validate_data(self, deployment='ops'):\\n self.validator.set_example(self.example)\\n\\n # Don't just use the built in validate_data method as this needs to be future proofed against C100 firmware\\n # upgrades. This upgrade will result in a new mode SELAP (R...CNTL2MODE == 64).\\n self.validator.validate_capture_file_counts()\\n self.validator.validate_capture_file_waveforms()\\n\\n # Many of these examples will have some amount of rounding error.\\n self.validator.validate_waveform_times(min_end=10.0, max_start=-1534.0, step_size=0.2)\\n self.validator.validate_cavity_modes(mode=(4, 64), deployment=deployment)\\n self.validator.validate_zones()\",\n \"def validate(self):\\n try:\\n self.values.clear()\\n self.values.append(int(self.e1.get()))\\n except ValueError:\\n messagebox.showwarning(\\n \\\"Bad input\\\",\\n \\\"Illegal values, please try again.\\\")\\n return False\\n\\n return True\",\n \"def test__validate_owner__1():\\n for field_value in (\\n 12.6,\\n ):\\n with vampytest.assert_raises(TypeError):\\n validate_owner(field_value)\",\n \"def validate_data(values):\\n try:\\n [int(value) for value in values]\\n if len(values) != 6:\\n raise ValueError(\\n f'Exactly 6 values are required - you provided {len(values)}'\\n )\\n except ValueError as e:\\n print(f'Invalid data entered: {e}, please try again!\\\\n')\\n return False\\n\\n return True\",\n \"def check_value(self, value):\",\n \"def is_valid(self, value):\\r\\n pass\",\n \"def validate(self, value: Any, low: int, high: int) -> bool:\\n pass\",\n \"def _further_validate_and_setup(self) -> None:\\n\\n # Make sure parameters make sense/are valid\\n if len(self.validated['learners']) != len(self.validated['param_grids']):\\n raise SchemaError(autos=None,\\n errors='The lists of of learners and parameter '\\n 'grids must be the same size.')\\n if (self.validated['hashed_features'] is not None\\n and self.validated['hashed_features'] == 0):\\n self.validated['hashed_features'] = self._n_features_feature_hashing\\n if self.validated['lognormal'] and self.validated['power_transform']:\\n raise SchemaError(autos=None,\\n errors='Both \\\"lognormal\\\" and \\\"power_transform\\\" '\\n 'were set simultaneously.')\\n if len(self.validated['learners']) != len(self.validated['param_grids']):\\n raise SchemaError(autos=None,\\n errors='The \\\"learners\\\" and \\\"param_grids\\\" '\\n 'parameters were both set and the '\\n 'lengths of the lists are unequal.')\",\n \"def test_admin_freeze_schema():\\n legal_filing = {'adminFreeze': ADMIN_FREEZE}\\n\\n is_valid, errors = validate(legal_filing, 'admin_freeze')\\n\\n if errors:\\n for err in errors:\\n print(err.message)\\n print(errors)\\n\\n assert is_valid\",\n \"def validate(cls, value):\\n return cls.properties.validate(value)\",\n \"def validate(entry: _LexiconEntry) -> None:\\n _entry_has_required_fields(entry)\\n _entry_field_values_are_not_empty(entry)\\n _entry_field_values_does_not_contain_infix_whitespace(entry)\\n _entry_tag_is_valid(entry)\\n _entry_compound_annotation_is_valid(entry)\\n _entry_morphophonemics_annotation_is_valid(entry)\\n _entry_features_annotation_is_valid(entry)\\n _entry_has_required_features(entry)\\n _entry_required_features_are_valid(entry)\\n _entry_optional_features_are_valid(entry)\\n _entry_features_are_not_redundant(entry)\",\n \"def testValid(self):\\n validate = timing_util.ValidateMeasurementsFlag\\n self.assertIs(validate([]), True)\\n self.assertIs(validate(['none']), True)\\n self.assertIs(validate(['end_to_end_runtime']), True)\\n self.assertIs(validate(['runtimes']), True)\\n self.assertIs(validate(['timestamps']), True)\\n self.assertIs(validate(['end_to_end_runtime', 'runtimes']), True)\\n self.assertIs(validate(['end_to_end_runtime', 'timestamps']), True)\\n self.assertIs(validate(['runtimes', 'timestamps']), True)\\n self.assertIs(\\n validate(['end_to_end_runtime', 'runtimes', 'timestamps']), True)\",\n \"def validate(self, list_value):\\n errors = DataDefinition.validate(self, list_value)\\n if errors:\\n return errors\\n\\n for index, value in enumerate(list_value):\\n errors = self.element_type.validate(value)\\n if errors:\\n msg = message_factory.get_message(\\n 'vapi.data.list.invalid.entry',\\n str(value), index)\\n return [msg] + errors\\n\\n return None\",\n \"def validate(self):\\r\\n for name in self._columns.keys():\\r\\n func_name = 'validate_{}'.format(name)\\r\\n val = getattr(self, name)\\r\\n if hasattr(self, func_name):\\r\\n val = getattr(self, func_name)(val)\\r\\n else:\\r\\n val = self.validate_field(name, val)\\r\\n setattr(self, name, val)\",\n \"def test_oneOf_and_anyOf_are_weak_matches(self):\\r\\n\\r\\n validator = Draft4Validator(\\r\\n {\\r\\n \\\"minProperties\\\" : 2,\\r\\n \\\"anyOf\\\" : [{\\\"type\\\" : \\\"string\\\"}, {\\\"type\\\" : \\\"number\\\"}],\\r\\n \\\"oneOf\\\" : [{\\\"type\\\" : \\\"string\\\"}, {\\\"type\\\" : \\\"number\\\"}],\\r\\n }\\r\\n )\\r\\n best = self.best_match(validator.iter_errors({}))\\r\\n self.assertEqual(best.validator, \\\"minProperties\\\")\",\n \"def test_validate_valid_resume(self):\\n # DEV: `validate` will raise an exception if it could not validate\\n self.assertIsNone(resumeschema.validate(self.valid_resume))\",\n \"def validate(self, converted_value, context):\\n pass\",\n \"def test_firms_conversion_schema():\\n legal_filing = {'conversion': FIRMS_CONVERSION}\\n\\n is_valid, errors = validate(legal_filing, 'conversion')\\n\\n if errors:\\n for err in errors:\\n print(err.message)\\n print(errors)\\n\\n assert is_valid\",\n \"def test_Validator_is_valid_two_arguments(self):\\n\\n validator = validators.Draft7Validator({})\\n with self.assertWarns(DeprecationWarning) as w:\\n result = validator.is_valid(\\\"foo\\\", {\\\"type\\\": \\\"number\\\"})\\n\\n self.assertFalse(result)\\n self.assertEqual(w.filename, __file__)\\n self.assertTrue(\\n str(w.warning).startswith(\\n \\\"Passing a schema to Validator.is_valid is deprecated \\\",\\n ),\\n )\",\n \"def validate(self, value):\\n # Use the parent's handling of required fields, etc.\\n super().validate(value)\\n for email in value:\\n validate_email(email)\",\n \"def verify_post_data ( ):\\n # check every field is present\\n try:\\n request.json[ 'source_lang' ]\\n request.json[ 'target_lang' ]\\n request.json[ 'text' ]\\n\\n TranslatorApp.verify_rpc_value ( request.json )\\n\\n except KeyError: # All the values are not present\\n # 400 Bad Request\\n abort ( 400, \\\"All mandatory fields are not provided\\\" )\\n except ValueError as err:\\n # 422 Unprocessable Entity\\n abort ( 422, \\\"Unprocessable value: {0}\\\".format ( err.args ) )\\n except BadRequest:\\n # 400 Bad Request\\n abort ( 400, \\\"Provided values are having malformed syntax\\\" )\",\n \"def _validate(self):\\n schema_version = util.schemas[self.schema_name]\\n stored_schemas = util.stored_schemas\\n\\n try:\\n schema_obj = stored_schemas[\\n \\\"http://redfish.dmtf.org/schemas/v1/\\\" + schema_version]\\n except KeyError:\\n raise OneViewRedfishError(\\\"{} not found\\\".format(schema_version))\\n\\n resolver = jsonschema.RefResolver('', schema_obj, store=stored_schemas)\\n jsonschema.validate(self.redfish, schema_obj, resolver=resolver)\",\n \"def validate_values(self):\\n if self.avp_def.has_defined_values():\\n defined_values = dict(self.avp_def.attr_defined_values)\\n if self.avp_value not in defined_values.values():\\n raise ValueError(\\n f\\\"{self.avp_def.attr_name} - value {self.avp_value} \\\"\\n \\\"is not allowed\\\")\\n\\n return True\",\n \"def test__validate_status__1():\\n for input_value in (\\n 12.6,\\n ):\\n with vampytest.assert_raises(TypeError):\\n validate_status(input_value)\",\n \"def _check_validity(self):\\n pass\",\n \"def validate(self, data):\\n l = len(data[\\\"start_times\\\"])\\n for i in range(l):\\n if data[\\\"start_times\\\"][i]>=data['end_times'][i]:\\n raise serializers.ValidationError(\\\"Start times should come before end times\\\") \\n return data\",\n \"def check_consistency(self) -> 'Schema':\\n errors = []\\n fields = self.__fields__\\n for k, v in fields.items():\\n _, err = v.validate(getattr(self, k), fields, loc=k)\\n if err:\\n errors.append(err)\\n if errors:\\n raise ValidationError(errors, self.__class__)\\n return self\",\n \"def test_minmax(self):\\n val = DwcaValidator(yaml.load(self.yaml_value, Loader=yaml.FullLoader),\\n error_handler=WhipErrorHandler)\\n document = {'percentage': 9.}\\n self.assertFalse(val.validate(document))\\n document = {'percentage': 2.1}\\n self.assertFalse(val.validate(document))\\n\\n val = DwcaValidator(yaml.load(self.yaml_value, Loader=yaml.FullLoader),\\n error_handler=WhipErrorHandler)\\n document = {'individualCount': 9}\\n self.assertFalse(val.validate(document))\\n document = {'individualCount': 2}\\n self.assertFalse(val.validate(document))\",\n \"def test_special_case(self):\\n cases = [\\n ('3467875434578764345789654', False),\\n ('AAAAAAAAAAA', False),\\n ('', False),\\n ]\\n for titulo_eleitoral, is_valid in cases:\\n self.assertEqual(self.titulo_eleitoral.validate(titulo_eleitoral), is_valid)\",\n \"def validate(self, test_data):\\n if not isinstance(test_data, np.number):\\n raise ValidationError('Invalid type/value.', 'numpy.number',\\n type(test_data))\\n if self.max_value is not None and test_data > self.max_value:\\n raise ValidationError('Maximum value exceeded.',\\n self.max_value, test_data)\\n if self.min_value is not None and test_data < self.min_value:\\n raise ValidationError('Minimum value undercut.',\\n self.min_value, test_data)\\n if test_data.dtype != self.dtype:\\n raise ValidationError('Invalid dtype.', self.dtype,\\n test_data.dtype)\",\n \"def validate_subset_of_schema(self, schema):\\n super(BooleanAttributeSchema, self).validate_subset_of_schema(schema)\\n\\n if not self.values.issubset(schema.values):\\n raise AttributeSchemaError(\\n \\\"Values %s are not a subset of %s\\\"\\n % (self.values, schema.values)\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6888409","0.6783357","0.6623987","0.6546313","0.6526652","0.6525666","0.64644414","0.6449077","0.6449077","0.64253944","0.6407268","0.63882005","0.6381051","0.63460135","0.63460135","0.6308076","0.6282616","0.6282616","0.6281018","0.62414503","0.6232009","0.62216306","0.62011117","0.61829644","0.6167385","0.61612105","0.61578304","0.6143167","0.6140295","0.6139734","0.6124934","0.6124913","0.6119326","0.61015457","0.6089719","0.6080682","0.60776293","0.6052787","0.60509247","0.60407007","0.6039464","0.60380715","0.60380715","0.60380715","0.60380715","0.60380715","0.60380715","0.60380715","0.60380715","0.6029609","0.6018973","0.6004776","0.60047483","0.59884036","0.5941646","0.5941646","0.59353673","0.59353447","0.59286267","0.59270537","0.59208256","0.591786","0.5902043","0.58912665","0.5888456","0.5885104","0.5882367","0.58812314","0.58796537","0.5877526","0.58771634","0.58743876","0.58735776","0.58677626","0.5864473","0.58637786","0.58616245","0.58590823","0.5856415","0.5853955","0.58535445","0.5852994","0.5849558","0.58392787","0.58340293","0.58264273","0.5824494","0.58237123","0.582223","0.5814511","0.5813703","0.5813143","0.5809729","0.5809421","0.5809065","0.58073723","0.5802463","0.5793866","0.57930636","0.579266","0.57925934"],"string":"[\n \"0.6888409\",\n \"0.6783357\",\n \"0.6623987\",\n \"0.6546313\",\n \"0.6526652\",\n \"0.6525666\",\n \"0.64644414\",\n \"0.6449077\",\n \"0.6449077\",\n \"0.64253944\",\n \"0.6407268\",\n \"0.63882005\",\n \"0.6381051\",\n \"0.63460135\",\n \"0.63460135\",\n \"0.6308076\",\n \"0.6282616\",\n \"0.6282616\",\n \"0.6281018\",\n \"0.62414503\",\n \"0.6232009\",\n \"0.62216306\",\n \"0.62011117\",\n \"0.61829644\",\n \"0.6167385\",\n \"0.61612105\",\n \"0.61578304\",\n \"0.6143167\",\n \"0.6140295\",\n \"0.6139734\",\n \"0.6124934\",\n \"0.6124913\",\n \"0.6119326\",\n \"0.61015457\",\n \"0.6089719\",\n \"0.6080682\",\n \"0.60776293\",\n \"0.6052787\",\n \"0.60509247\",\n \"0.60407007\",\n \"0.6039464\",\n \"0.60380715\",\n \"0.60380715\",\n \"0.60380715\",\n \"0.60380715\",\n \"0.60380715\",\n \"0.60380715\",\n \"0.60380715\",\n \"0.60380715\",\n \"0.6029609\",\n \"0.6018973\",\n \"0.6004776\",\n \"0.60047483\",\n \"0.59884036\",\n \"0.5941646\",\n \"0.5941646\",\n \"0.59353673\",\n \"0.59353447\",\n \"0.59286267\",\n \"0.59270537\",\n \"0.59208256\",\n \"0.591786\",\n \"0.5902043\",\n \"0.58912665\",\n \"0.5888456\",\n \"0.5885104\",\n \"0.5882367\",\n \"0.58812314\",\n \"0.58796537\",\n \"0.5877526\",\n \"0.58771634\",\n \"0.58743876\",\n \"0.58735776\",\n \"0.58677626\",\n \"0.5864473\",\n \"0.58637786\",\n \"0.58616245\",\n \"0.58590823\",\n \"0.5856415\",\n \"0.5853955\",\n \"0.58535445\",\n \"0.5852994\",\n \"0.5849558\",\n \"0.58392787\",\n \"0.58340293\",\n \"0.58264273\",\n \"0.5824494\",\n \"0.58237123\",\n \"0.582223\",\n \"0.5814511\",\n \"0.5813703\",\n \"0.5813143\",\n \"0.5809729\",\n \"0.5809421\",\n \"0.5809065\",\n \"0.58073723\",\n \"0.5802463\",\n \"0.5793866\",\n \"0.57930636\",\n \"0.579266\",\n \"0.57925934\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":4496,"cells":{"query":{"kind":"string","value":"Validate manifest against the twine schema."},"document":{"kind":"string","value":"def _validate_manifest(self, kind, source, cls=None, **kwargs):\n data = self._load_json(kind, source, **kwargs)\n\n # TODO elegant way of cleaning up this nasty serialisation hack to manage conversion of outbound manifests to primitive\n inbound = True\n if hasattr(data, \"to_primitive\"):\n inbound = False\n data = data.to_primitive()\n\n self._validate_against_schema(kind, data)\n self._validate_all_expected_datasets_are_present_in_manifest(manifest_kind=kind, manifest=data)\n\n if cls and inbound:\n return cls(**data)\n\n return data"},"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 validate_manifest(\n request: ValidateManifestRequest = Body(...),\n schema: Any = Depends(get_description_schema),\n) -> ValidateManifestResponse:\n\n _, response = _validate_manifest(request, schema)\n return response","def validate_input_manifest(self, source, **kwargs):\n return self._validate_manifest(\"input_manifest\", source, **kwargs)","def check_manifest(manifest):\n if not manifest:\n raise Exception('manifest is null')\n\n for key in ['dublin_core', 'checking', 'projects']:\n if key not in manifest:\n raise Exception('manifest missing key \"{0}\"'.format(key))\n\n # check checking\n for key in ['checking_entity', 'checking_level']:\n if key not in manifest['checking']:\n raise Exception('manifest missing checking key \"{0}\"'.format(key))\n\n if not isinstance(manifest['checking']['checking_entity'], list):\n raise Exception('manifest key checking.checking_entity must be an array')\n\n # check projects\n if not isinstance(manifest['projects'], list):\n raise Exception('manifest key projects must be an array')\n\n for key in ['categories', 'identifier', 'path', 'sort', 'title', 'versification']:\n for project in manifest['projects']:\n if key not in project:\n raise Exception('manifest missing project key \"{0}\"'.format(key))\n\n # check dublin_core\n for key in ['conformsto', 'contributor', 'creator', 'description', 'format', 'identifier', 'issued', 'language',\n 'modified', 'publisher', 'relation', 'rights', 'source', 'subject', 'title', 'type', 'version']:\n if key not in manifest['dublin_core']:\n raise Exception('manifest missing dublin_core key \"{0}\"'.format(key))\n\n expectedRCVersion = 'rc0.2'\n if manifest['dublin_core']['conformsto'].lower() != expectedRCVersion:\n raise Exception('unsupported rc version {}. Expected {}'.format(manifest['dublin_core']['conformsto'], expectedRCVersion))\n\n for key in ['direction', 'identifier', 'title']:\n if key not in manifest['dublin_core']['language']:\n raise Exception('manifest missing dublin_core.language key \"{0}\"'.format(key))\n\n if not isinstance(manifest['dublin_core']['source'], list):\n raise Exception('manifest key dublin_core.source must be an array')\n\n for key in ['version', 'identifier', 'language']:\n for source in manifest['dublin_core']['source']:\n if key not in source:\n raise Exception('manifest missing dublin_core.source key \"{0}\"'.format(key))","def validate_manifest(parser, options):\n if not options.manifest:\n return\n\n template = \"When specifying --manifest, {0} is also required\"\n\n if not options.manifest_id:\n parser.error(template.format(\"--manifest-id\"))\n \n if not options.manifest_service:\n parser.error(template.format(\"--manifest-service\"))\n\n if not options.manifest_version:\n parser.error(template.format(\"--manifest-version\"))","def validate_manifest(manifest_json):\n manifest_json = copy.deepcopy(manifest_json)\n for field in [\"schemes\", \"host\", \"basePath\", \"info\"]:\n if field not in manifest_json:\n raise exceptions.ValidationError(\n click.style(\"Field '{}' is missing from the manifest file.\", fg=\"red\").format(field),\n json=manifest_json)\n\n for field in [\"contact\", \"title\", \"description\", \"x-21-total-price\", \"x-21-quick-buy\", \"x-21-category\"]:\n if field not in manifest_json[\"info\"]:\n raise exceptions.ValidationError(\n click.style(\n \"Field '{}' is missing from the manifest file under the 'info' section.\",\n fg=\"red\").format(field),\n json=manifest_json)\n\n for field in {\"name\", \"email\"}:\n if field not in manifest_json[\"info\"][\"contact\"]:\n raise exceptions.ValidationError(\n click.style(\n \"Field '{}' is missing from the manifest file under the 'contact' section.\", fg=\"red\")\n .format(field),\n json=manifest_json)\n\n for field in [\"min\", \"max\"]:\n if field not in manifest_json[\"info\"][\"x-21-total-price\"]:\n raise exceptions.ValidationError(\n click.style(\"Field '{}' is missing from the manifest file under the \"\n \"'x-21-total-price' section.\",\n fg=\"red\"),\n json=manifest_json)\n\n if len(manifest_json[\"schemes\"]) == 0:\n raise exceptions.ValidationError(\n click.style(\n \"You have to specify either HTTP or HTTPS for your endpoint under the \"\n \"`schemes` section.\",\n fg=\"red\"),\n json=manifest_json)\n\n valid_app_categories = {'blockchain', 'entertainment', 'social', 'markets', 'utilities', 'iot'}\n if manifest_json[\"info\"][\"x-21-category\"].lower() not in valid_app_categories:\n valid_categories = \", \".join(valid_app_categories)\n raise exceptions.ValidationError(\n click.style(\"'{}' is not a valid category for the 21 marketplace. Valid categories are {}.\",\n fg=\"red\").format(\n manifest_json[\"info\"][\"x-21-category\"], valid_categories),\n json=manifest_json)","def _validate(self):\n All = voluptuous.All\n Required = voluptuous.Required\n Length = voluptuous.Length\n Extra = voluptuous.Extra\n\n schema = voluptuous.Schema({\n Required('description'): voluptuous.All(str, Length(min=5)),\n Required('environments'): dict,\n Required('application'): {\n Required('name'): str,\n Required('scenario'): [{\n Required('driver'): str,\n Required('description'): All(str, Length(min=5)),\n Extra: object}]}})\n try:\n schema(self.marmite_tree)\n except voluptuous.MultipleInvalid as e:\n LOG.error(\"Failed to validate %s/marmite.yaml structure: %s\" %\n (self.fs_layer.base_dir, e))\n raise InvalidStructure()","def validate_output_manifest(self, source, **kwargs):\n return self._validate_manifest(\"output_manifest\", source, **kwargs)","def test_is_valid_manifest_format_with_many_types_of_errors(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_many_types_of_errors.tsv\",\n )\n error_log = caplog.text\n manifest_with_many_types_of_errors_helper(error_log)\n assert result == False","def validate(self):\n import os\n\n if self.kind == KDM.INTEROP:\n with open(os.path.join(os.path.dirname(__file__), 'xsd', 'interop.xsd'), 'r') as f:\n schema = f.read()\n elif self.kind == KDM.SMPTE:\n with open(os.path.join(os.path.dirname(__file__), 'xsd', 'smpte.xsd'), 'r') as f:\n schema = f.read()\n\n base_dir = os.getcwd()\n os.chdir(os.path.join(os.path.dirname(__file__), 'xsd'))\n try:\n schema = ET.XMLSchema(ET.XML(schema))\n xmlparser = ET.XMLParser(schema=schema)\n ET.fromstring(self.raw, xmlparser)\n finally:\n os.chdir(base_dir)","def _validate_all_expected_datasets_are_present_in_manifest(self, manifest_kind, manifest):\n # This is the manifest schema included in the `twine.json` file, not the schema for `manifest.json` files.\n manifest_schema = getattr(self, manifest_kind)\n\n for expected_dataset_name, expected_dataset_schema in manifest_schema[\"datasets\"].items():\n if expected_dataset_name in manifest[\"datasets\"]:\n continue\n\n if expected_dataset_schema.get(\"optional\", False):\n continue\n\n raise exceptions.invalid_contents_map[manifest_kind](\n f\"A dataset named {expected_dataset_name!r} is expected in the {manifest_kind} but is missing.\"\n )","def _validate(self):\n if not self._contents.has_key('type'):\n raise ValidationFailed(\"Metadata file %s contains no type field\" % (self._filename))\n \n if not self._contents.has_key('version'):\n raise ValidationFailed(\"Metadata file %s contains no version field\" %\n (self._filename))","def metadata_validate(self):\n # Set path to `service_schema` stored in the `resources` directory from cwd of `mpe_service.py`\n current_path = Path(__file__).parent\n relative_path = '../../snet/snet_cli/resources/service_schema'\n path_to_schema = (current_path / relative_path).resolve()\n with open(path_to_schema, 'r') as f:\n schema = json.load(f)\n metadata = load_mpe_service_metadata(self.args.metadata_file)\n try:\n validate(instance=metadata.m, schema=schema)\n except Exception as e:\n docs = \"http://snet-cli-docs.singularitynet.io/service.html\"\n error_message = f\"\\nVisit {docs} for more information.\"\n if e.validator == 'required':\n raise ValidationError(e.message + error_message)\n elif e.validator == 'minLength':\n raise ValidationError(f\"`{e.path[-1]}` -> cannot be empty.\" + error_message)\n elif e.validator == 'minItems':\n raise ValidationError(f\"`{e.path[-1]}` -> minimum 1 item required.\" + error_message)\n elif e.validator == 'type':\n raise ValidationError(f\"`{e.path[-1]}` -> {e.message}\" + error_message)\n elif e.validator == 'enum':\n raise ValidationError(f\"`{e.path[-1]}` -> {e.message}\" + error_message)\n elif e.validator == 'additionalProperties':\n if len(e.path) != 0:\n raise ValidationError(f\"{e.message} in `{e.path[-2]}`.\" + error_message)\n else:\n raise ValidationError(f\"{e.message} in main object.\" + error_message)\n else:\n exit(\"OK. Ready to publish.\")","def _validate_against_schema(self, strand, data):\n schema = self._get_schema(strand)\n\n try:\n jsonschema_validate(instance=data, schema=schema)\n logger.debug(\"Validated %s against schema\", strand)\n\n except ValidationError as e:\n raise exceptions.invalid_contents_map[strand](str(e))","def supports_manifest(manifest):\n pass","def test_validate_valid_resume(self):\n # DEV: `validate` will raise an exception if it could not validate\n self.assertIsNone(resumeschema.validate(self.valid_resume))","def _validate(self):\n schema_version = util.schemas[self.schema_name]\n stored_schemas = util.stored_schemas\n\n try:\n schema_obj = stored_schemas[\n \"http://redfish.dmtf.org/schemas/v1/\" + schema_version]\n except KeyError:\n raise OneViewRedfishError(\"{} not found\".format(schema_version))\n\n resolver = jsonschema.RefResolver('', schema_obj, store=stored_schemas)\n jsonschema.validate(self.redfish, schema_obj, resolver=resolver)","def schema_check(self):\n\n try:\n self.schema.assertValid(self.get_content())\n except lxml.etree.DocumentInvalid:\n logger.error(\"PDU failed schema check\")\n for line in self.pretty_print_content().splitlines():\n logger.warning(line)\n raise","def validate_full_schema(self):\n #self.check_duplicate_labels()\n for record in self.extension_schema['schema']['@graph']:\n #self.check_whether_atid_and_label_match(record)\n if record['@type'] == \"rdfs:Class\":\n self.validate_class_schema(record)\n #self.validate_class_label(record[\"@id\"])\n self.validate_validation_field(record)\n elif record['@type'] == \"rdf:Property\":\n self.validate_property_schema(record)\n #self.validate_property_label(record[\"@id\"])\n #self.validate_domainIncludes_field(record[\"http://schema.org/domainIncludes\"])\n #self.validate_rangeIncludes_field(record[\"http://schema.org/rangeIncludes\"])\n #else:\n # raise ValueError('wrong @type value found: {}'.format(record))","def load_manifest(filename):\n\n data = manifest.load(filename)\n for field in manifest.validate(data):\n name = field.cfg or ''\n if name and name[-1] != '.':\n name += '>'\n name += field.name\n for msg in field.warnings:\n print('WARNING: {}@{} {}'.format(filename, name, msg))\n for msg in field.errors:\n print('CRITICAL: {}@{} {}'.format(filename, name, msg))\n return data","def check_app_manifest(api_docs_path, overrides, marketplace):\n if not os.path.exists(api_docs_path):\n raise exceptions.ValidationError(\n click.style(\"Could not find the manifest file at {}.\", fg=\"red\").format(api_docs_path))\n\n if os.path.isdir(api_docs_path):\n raise exceptions.ValidationError(\n click.style(\"{} is a directory. Please enter the direct path to the manifest file.\",\n fg=\"red\").format(api_docs_path))\n\n file_size = os.path.getsize(api_docs_path) / 1e6\n if file_size > 2:\n raise exceptions.ValidationError(\n click.style(\"The size of the manifest file at {} exceeds the maximum limit of 2MB.\", fg=\"red\")\n .format(api_docs_path))\n\n try:\n with open(api_docs_path, \"r\") as f:\n original_manifest_dict = yaml.load(f.read())\n\n manifest_dict = transform_manifest(original_manifest_dict, overrides, marketplace)\n\n # write back the manifest in case some clean up or overriding has happend\n with open(api_docs_path, \"w\") as f:\n yaml.dump(manifest_dict, f)\n\n return manifest_dict\n except (YAMLError, ValueError):\n raise exceptions.ValidationError(\n click.style(\"Your manifest file at {} is not valid YAML.\", fg=\"red\")\n .format(api_docs_path))","def readManifestFile(syn, manifestFile):\n table.test_import_pandas()\n import pandas as pd\n\n sys.stdout.write('Validation and upload of: %s\\n' % manifestFile)\n # Read manifest file into pandas dataframe\n df = pd.read_csv(manifestFile, sep='\\t')\n if 'synapseStore' not in df:\n df = df.assign(synapseStore=None)\n df.synapseStore[df['path'].apply(is_url)] = False # override synapseStore values to False when path is a url\n df.synapseStore[df['synapseStore'].isnull()] = True # remaining unset values default to True\n df.synapseStore = df.synapseStore.astype(bool)\n df = df.fillna('')\n\n sys.stdout.write('Validating columns of manifest...')\n for field in REQUIRED_FIELDS:\n sys.stdout.write('.')\n if field not in df.columns:\n sys.stdout.write('\\n')\n raise ValueError(\"Manifest must contain a column of %s\" % field)\n sys.stdout.write('OK\\n')\n\n sys.stdout.write('Validating that all paths exist')\n df.path = df.path.apply(_check_path_and_normalize)\n\n sys.stdout.write('OK\\n')\n\n sys.stdout.write('Validating that all files are unique...')\n if len(df.path) != len(set(df.path)):\n raise ValueError(\"All rows in manifest must contain a unique file to upload\")\n sys.stdout.write('OK\\n')\n\n sys.stdout.write('Validating provenance...')\n df = _sortAndFixProvenance(syn, df)\n sys.stdout.write('OK\\n')\n\n sys.stdout.write('Validating that parents exist and are containers...')\n parents = set(df.parent)\n for synId in parents:\n try:\n container = syn.get(synId, downloadFile=False)\n except SynapseHTTPError:\n sys.stdout.write('\\n%s in the parent column is not a valid Synapse Id\\n' % synId)\n raise\n if not is_container(container):\n sys.stdout.write('\\n%s in the parent column is is not a Folder or Project\\n' % synId)\n raise SynapseHTTPError\n sys.stdout.write('OK\\n')\n return df","def validate(self):\n print(\"Validating \")\n sha256_test = _get_file_sha256_hash(self.file_path)\n sha256_truth = self.metadata_pkg[\"hash\"]\n if sha256_test != sha256_truth:\n raise ValueError(\n f\"Hash of modelpkg file {os.path.basename(self.file_path)} ({sha256_test}) does not match truth hash ({sha256_truth}).\")","def test_validate_schema():\n data = {\n 'business': {\n 'cacheId': 1,\n 'foundingDate': '2007-04-08T00:00:00+00:00',\n 'identifier': 'CP1234567',\n 'legalName': 'legal name CP1234567'\n },\n }\n\n is_valid, _ = validate(data, 'business', validate_schema=True)\n\n assert is_valid","def validate_configuration_manifest(self, source, **kwargs):\n return self._validate_manifest(\"configuration_manifest\", source, **kwargs)","def schema_valid(arch, **kwargs):\n validator = relaxng(arch.tag)\n if validator and not validator.validate(arch):\n result = True\n for error in validator.error_log:\n _logger.error(tools.ustr(error))\n result = False\n return result\n return True","def validate(self, schema=os.path.join(os.path.dirname(__file__), 'am.xsd')):\n return validate_xml(schema, self.path, from_path=True)","def test_check_presence_only(self):\n schema = yaml.load(self.yaml_presence_check, Loader=yaml.FullLoader)\n val = DwcaValidator(schema, allow_unknown=True,\n error_handler=WhipErrorHandler)\n\n document = {'abundance': 'many'}\n self.assertTrue(val.validate(document))\n document = {'abundance': ''}\n self.assertTrue(val.validate(document))\n document = {'eventDate': ''}\n val.validate(document)\n self.assertEqual(val.errors, {})","def _validate_yaml(self):\n\n # verify the format is correct\n if self.validater == 'yamale':\n\n import yamale\n\n print('Validating yaml file with yamale.')\n cwd = Path(os.path.dirname(__file__))\n schema_path = str(cwd.parent / 'schema') + '/generic_schema.yaml'\n schema = yamale.make_schema(schema_path)\n data = yamale.make_data(self.yaml_path)\n try:\n yamale.validate(schema, data, strict=False)\n print('Validation success! 👍')\n return True\n except ValueError as e:\n print(\n 'Yamale found that your file, '\n + self.yaml_path\n + ' is not formatted correctly.'\n )\n print(e)\n return False\n else:\n print('Did not validate yaml.')\n print('If unexpected results occur, try installing yamale and rerun.')\n return True","def test_is_valid_manifest_format_with_invalid_sizes(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_invalid_sizes.tsv\"\n )\n error_log = caplog.text\n assert \"-1\" in error_log\n assert \"not_an_int\" in error_log\n assert \"3.34\" in error_log\n assert \"string_with_42\" in error_log\n assert result == False","def check_valid_schema(context):\n data = context.response.json()\n validate_schema(data)","def test_is_valid_valid_resume(self):\n self.assertTrue(resumeschema.is_valid(self.valid_resume))","def test_is_valid_manifest_format_with_no_errors(caplog):\n assert (\n is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_no_errors.tsv\"\n )\n == True\n )\n assert caplog.text == \"\"","def validate_schema(self, schema):\n json_schema_path = os.path.join(_ROOT, 'data', 'schema.json')\n json_schema = load_json_or_yaml(json_schema_path)\n return validate(schema, json_schema)","def _validate_twine_version(self, twine_file_twined_version):\n installed_twined_version = pkg_resources.get_distribution(\"twined\").version\n logger.debug(\n \"Twine versions... %s installed, %s specified in twine\", installed_twined_version, twine_file_twined_version\n )\n if (twine_file_twined_version is not None) and (installed_twined_version != twine_file_twined_version):\n raise exceptions.TwineVersionConflict(\n f\"Twined library version conflict. Twine file requires {twine_file_twined_version} but you have {installed_twined_version} installed\"\n )","def test_schema_valid(path, name, data):\n schemas = metaschemas()\n if name in ('release-schema.json', 'release-package-schema.json'):\n metaschema = schemas['release_package_metaschema']\n elif name == 'record-package-schema.json':\n metaschema = schemas['record_package_metaschema']\n elif name in ('project-schema.json', 'project-package-schema.json'):\n metaschema = schemas['project_package_metaschema']\n else:\n metaschema = schemas['metaschema']\n\n validate_json_schema(path, name, data, metaschema)","def validate_metadata(self, metadata: Dict[str, dict]):\n encoder = NWBMetaDataEncoder()\n # The encoder produces a serialiazed object so we de serialized it for comparison\n serialized_metadata = encoder.encode(metadata)\n decoded_metadata = json.loads(serialized_metadata)\n validate(instance=decoded_metadata, schema=self.get_metadata_schema())\n if self.verbose:\n print(\"Metadata is valid!\")","def validate(args):\n args = {k.lstrip('-').lower().replace('-', '_'): v\n for k, v in args.items()}\n schema = Schema({\n 'ptvsd': Or(None, And(Use(int), lambda port: 1 <= port <= 65535)),\n 'root_dir': os.path.exists,\n 'resume': bool,\n })\n args = schema.validate(args)\n return args","def validate(self, namespace):\n pass","def test_is_valid_manifest_with_wide_row(caplog):\n logging.getLogger().setLevel(logging.WARNING)\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_wide_row.tsv\",\n )\n wide_warning = f\"line 3, number of fields (6) in row is unequal to number of column names in manifest (5)\"\n assert wide_warning in caplog.text\n assert result == True","def test_is_valid_invalid_resume(self):\n self.assertFalse(resumeschema.is_valid(self.invalid_resume))","def app_validate(data):\n\n schema = json.load(open('schemas/app_description_schema.json', 'r'))\n try:\n jsonschema.validate(data, schema)\n except jsonschema.ValidationError as e:\n raise InvalidApplicationDescription(str(e))\n except jsonschema.SchemaError:\n log.exception('BUG: invalid schema for application descriptions')\n raise ZoeLibException('BUG: invalid schema for application descriptions')\n\n # Start non-schema, semantic checks\n if data['version'] != zoe_lib.version.ZOE_APPLICATION_FORMAT_VERSION:\n raise InvalidApplicationDescription('Application description version mismatch (expected: {}, found: {}'.format(zoe_lib.version.ZOE_APPLICATION_FORMAT_VERSION, data['version']))\n\n found_monitor = False\n for service in data['services']:\n if service['monitor']:\n found_monitor = True\n\n service['resources']['memory']['max'] = zoe_lib.config.get_conf().max_memory_limit * (1024 ** 3)\n if service['resources']['memory']['min'] is not None and service['resources']['memory']['min'] > service['resources']['memory']['max']:\n raise InvalidApplicationDescription(msg='service {} tries to reserve more memory than the administrative limit'.format(service['name']))\n\n if service['resources']['cores']['min'] is None:\n service['resources']['cores']['min'] = 0.1\n\n if not found_monitor:\n raise InvalidApplicationDescription(msg=\"at least one process should have the monitor property set to true\")","def test_validate_invalid_resume(self):\n # DEV: `validate` will raise an exception if it could not validate\n with self.assertRaises(jsonschema.ValidationError):\n resumeschema.validate(self.invalid_resume)","def isValidForSchema(schema):\n\n return True","def validate_payload(cls, event):\n # TODO: Use invenio-jsonschemas/jsonresolver instead of this\n # Validate against Event JSONSchema\n # NOTE: raises `jsonschemas.ValidationError`\n cls._jsonschema_validator.validate(event)\n\n # Validate using marshmallow loader\n for payload in event:\n errors = RelationshipSchema(check_existing=True).validate(payload)\n if errors:\n raise MarshmallowValidationError(str(errors) + \"payload\" + str(payload))","def validate(entry: _LexiconEntry) -> None:\n _entry_has_required_fields(entry)\n _entry_field_values_are_not_empty(entry)\n _entry_field_values_does_not_contain_infix_whitespace(entry)\n _entry_tag_is_valid(entry)\n _entry_compound_annotation_is_valid(entry)\n _entry_morphophonemics_annotation_is_valid(entry)\n _entry_features_annotation_is_valid(entry)\n _entry_has_required_features(entry)\n _entry_required_features_are_valid(entry)\n _entry_optional_features_are_valid(entry)\n _entry_features_are_not_redundant(entry)","def test_invalid_manifest_filepath(self):\n load_manifest(\"./ehiiehaiehnatheita\")","def test_theme_manifest(err, xpi_package=None):\n\n # Don't even both with the test(s) if there's no chrome.manifest.\n chrome = err.get_resource('chrome.manifest')\n if not chrome:\n return\n\n for triple in chrome.triples:\n subject = triple['subject']\n # Test to make sure that the triple's subject is valid\n if subject not in ('skin', 'style'):\n err.warning(\n err_id=('themes', 'test_theme_manifest',\n 'invalid_chrome_manifest_subject'),\n warning='Invalid chrome.manifest subject',\n description=('chrome.manifest files for full themes are only '\n \"allowed to have 'skin' and 'style' items. \"\n 'Other types of items are disallowed for '\n 'security reasons.',\n 'Invalid subject: %s' % subject),\n filename=triple['filename'],\n line=triple['line'],\n context=triple['context'])","def test_admin_freeze_schema():\n legal_filing = {'adminFreeze': ADMIN_FREEZE}\n\n is_valid, errors = validate(legal_filing, 'admin_freeze')\n\n if errors:\n for err in errors:\n print(err.message)\n print(errors)\n\n assert is_valid","def validate():","def test_is_valid_manifest_format_using_line_limit(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_invalid_sizes.tsv\",\n line_limit=3,\n )\n error_log = caplog.text\n assert \"line 2\" in error_log\n assert \"line 3\" in error_log\n assert \"line 4\" not in error_log\n assert \"line 5\" not in error_log\n assert result == False","def test_is_valid_manifest_with_missing_size_column(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_missing_size_column.tsv\",\n )\n missing_size_message = (\n 'could not find a column name corresponding to required \"Columns.SIZE\"'\n )\n assert missing_size_message in caplog.text\n assert result == False","def _validate_yaml(schema, config):\n check = pykwalify_core.Core(\n source_data=config, schema_files=[\"{}/{}.yml\".format(conf_schema_path, schema)])\n try:\n check.validate(raise_exception=True)\n except pykwalify_errors.SchemaError as e:\n _logger.error(\"Schema validation failed\")\n raise Exception(\"File does not conform to {} schema: {}\".format(schema, e))","def test_sa_mismatch_manifest_file_and_ecosystem(self):\n with open(str(Path(__file__).parent.parent.parent) +\n '/data/manifests/202/npmlist.json', 'rb') as fp:\n fs = FileStorage(stream=fp, filename='npmlist.json')\n with pytest.raises(Exception) as exception:\n sa_post_request = StackAnalysesPostRequest(manifest=fs, file_path='/tmp/bin',\n ecosystem='pypi', show_transitive=True)\n sa = StackAnalyses(sa_post_request)\n sa.post_request()\n self.assertIs(exception.type, ValidationError)","def test_is_valid_manifest_format_with_invalid_md5_values(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_invalid_md5_values.tsv\"\n )\n\n error_log = caplog.text\n manifest_with_invalid_md5_values_helper(error_log)\n base64_encoded_md5 = '\"jd2L5LF5pSmvpfL/rkuYWA==\"'\n assert base64_encoded_md5 in error_log\n assert result == False","def is_manifest_list(self):\n return False","def validate():\n description = f\"Validate XML metadata.\"\n parser = argparse.ArgumentParser(\n description=description,\n formatter_class=argparse.ArgumentDefaultsHelpFormatter\n )\n\n help = \"XML file or URL\"\n parser.add_argument('infile', help=help)\n\n help = (\n \"Format ID for metadata standard. If this argument is supplied, \"\n \"only that format ID will be checked. If not, all format IDs will be \"\n \"checked.\"\n )\n parser.add_argument('--format-id',\n help=help,\n choices=d1_scimeta.util.get_supported_format_id_list())\n\n help = \"Verbosity of log messages.\"\n choices = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']\n parser.add_argument('-v', '--verbosity', help=help, choices=choices,\n default='INFO')\n\n args = parser.parse_args()\n\n validator = XMLValidator(verbosity=args.verbosity)\n validator.validate(args.infile, format_id=args.format_id)","def read_manifest(self): # -> None:\n ...","def _validate_against_schema(config):\n logging.info(\"Validating config file against the schema\")\n try:\n c = Core(source_data=config, schema_files=[CONFIG_SCHEMA])\n c.validate(raise_exception=True)\n except Exception as e:\n logging.error(\"Failed when validating schema: %s\", e)\n logging.info(\"Dumping rendered template:\\n%s\", dump_rendered_config_file(config))\n raise","def validateBoot (self):\n self.mountBootPartition()\n stateDictionary = self._createBootInstallationDictionary()\n self._writeDictionaryAsJson(stateDictionary, self._getBootInstallationFilePath())\n self._log(\"validate-boot\").notice(\"boot partition is validated\")","def test_required_fields_schema_version(self):\n\n del self.validator.adata.uns[\"schema_version\"]\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors,\n [\n \"ERROR: adata has no schema definition in 'adata.uns'. \"\n \"Validation cannot be performed.\"\n ],\n )","def validate_data(self, deployment='ops'):\n self.validator.set_example(self.example)\n\n # Don't just use the built in validate_data method as this needs to be future proofed against C100 firmware\n # upgrades. This upgrade will result in a new mode SELAP (R...CNTL2MODE == 64).\n self.validator.validate_capture_file_counts()\n self.validator.validate_capture_file_waveforms()\n\n # Many of these examples will have some amount of rounding error.\n self.validator.validate_waveform_times(min_end=10.0, max_start=-1534.0, step_size=0.2)\n self.validator.validate_cavity_modes(mode=(4, 64), deployment=deployment)\n self.validator.validate_zones()","def validate_schema(self):\n for _, certificate in self.certificates_to_issue.items():\n with open(certificate.signed_cert_file_name) as cert:\n cert_json = json.load(cert)\n validate_unsigned_v1_2(cert_json)","def validate(self):\n with open(os.path.join(settings.MEDIA_ROOT, self.file.name)) as file:\n lines = file.readlines()\n validators = ['os.', 'from os', 'io.', 'from io', 'open(', 'system(']\n for line in lines:\n for validator in validators:\n if validator in line:\n return False\n return True","def test_validate_business_schema():\n data = {\n 'business': {\n 'cacheId': 1,\n 'foundingDate': '2007-04-08T00:00:00+00:00',\n 'identifier': 'CP1234567',\n 'lastLedgerTimestamp': '2019-04-15T20:05:49.068272+00:00',\n 'lastPreBobFilingTimestamp': '2019-04-15T20:05:49.068272+00:00',\n 'legalName': 'legal name - CP1234567'\n },\n }\n\n is_valid, _ = validate(data, 'business', validate_schema=True)\n\n assert is_valid","def validate_available(parser, options):\n if not options.available:\n return\n\n if not options.manifest_id:\n parser.error(\"When specifying --available, --manifest-id is also required\")","def validate(self) -> bool:\n\n # Start by reading in the blueprint schema json\n schema = json.loads(pkgutil.get_data(\"FactorioTools\", \"blueprintSchema.json\"))\n\n # Validate the object's schema against the blueprintSchema JSON\n try:\n jsonschema.validate(self.data, schema)\n return True\n except jsonschema.ValidationError:\n pass\n\n return False","def semantic_validate(instance):\n unknown_templates = {}\n for name, requires in instance[\"application\"][\"requires\"].items():\n if name in instance[\"application\"][\"services\"]:\n raise ValidationError(errors=[\n \"/application/requires/{}: the name {} conflicts with service\"\n \" /application/services/{}\".format(name,\n repr(name),\n name),\n ])\n if requires[\"template\"] not in instance[\"local\"][\"templates\"]:\n unknown_templates[\"/application/requires/{}/template\".format(\n name)] = requires[\"template\"]\n for service_name, service in instance[\"application\"][\"services\"].items():\n for name, requires in service[\"requires\"].items():\n if name in instance[\"application\"][\"requires\"]:\n raise ValidationError(errors=[\n \"/application/services/{}/requires/{}: the name {}\"\n \" conflicts with /application/requires/{}\".format(\n service_name, name, repr(name), name)\n ])\n if requires[\"template\"] not in instance[\"local\"][\"templates\"]:\n unknown_templates[\n \"/application/services/{}/requires/{}/template\".\n format(service_name, name)] = requires[\"template\"]\n if unknown_templates:\n raise ValidationError(errors=[\n \"{}: the template {} does not exist \"\n \"in /local/templates\".format(path, repr(name))\n for (path, name) in unknown_templates.items()\n ])","def test_sa_invalid_manifest_file(self):\n with open(str(Path(__file__).parent.parent.parent) +\n '/data/manifests/400/npmlist.json', 'rb') as fp:\n fs = FileStorage(stream=fp, filename='npmlist.json')\n sa_post_request = StackAnalysesPostRequest(manifest=fs, file_path='/tmp/bin',\n ecosystem='npm', show_transitive=True)\n sa = StackAnalyses(sa_post_request)\n with pytest.raises(Exception) as exception:\n sa.post_request()\n self.assertIs(exception.type, SAInvalidInputException)","def validate(self):\n return _libsbml.SBMLExternalValidator_validate(self)","def test_is_valid_manifest_with_missing_md5_column(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_missing_md5_column.tsv\",\n )\n missing_md5_message = (\n 'could not find a column name corresponding to required \"Columns.MD5\"'\n )\n assert missing_md5_message in caplog.text\n assert result == False","def validate(self):\n allowed_backbones = ['resnet50', 'resnet101', 'resnet152']\n backbone = self.backbone.split('_')[0]\n\n if backbone not in allowed_backbones:\n raise ValueError('Backbone (\\'{}\\') not in allowed backbones ({}).'.format(backbone, allowed_backbones))","def test_manifest(self):\n self.parse_manifest()\n\n ids = {}\n errors = []\n collisions = []\n manifest = self.cryptomattes[self.selection][\"names_to_IDs\"]\n for name, idvalue in manifest.iteritems():\n if mm3hash_float(name) != idvalue:\n errors.append(\"computed ID doesn't match manifest ID: (%s, %s)\" % (idvalue, mm3hash_float(name)))\n else:\n if idvalue in ids:\n collisions.append(\"colliding: %s %s\" % (ids[idvalue], name))\n ids[idvalue] = name\n\n print \"Tested %s, %s names\" % (self.nuke_node.name(), len(manifest))\n print \" \", len(errors), \"non-matching IDs between python and c++.\"\n print \" \", len(collisions), \"hash collisions in manifest.\"\n\n return errors, collisions","def test_is_valid_manifest_format_with_invalid_authz_resources(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_invalid_authz_resources.tsv\",\n )\n error_log = caplog.text\n assert '\"invalid_authz\"' in error_log\n assert '\"/\"' in error_log\n assert '\"//\"' in error_log\n assert '\"///\"' in error_log\n assert '\"invalid_authz2\"' in error_log\n assert result == False","def __validate():\n # TODO: implement","def test_invalid_schema():\n # setup\n uid = uuid.uuid4()\n schema_dir = f'/tmp/{uid}'\n schema_file = f'{schema_dir}/bad_schema.json'\n os.makedirs(schema_dir)\n text_file = open(schema_file, 'w')\n text_file.write('this will fail[];fail()')\n text_file.close()\n\n data = {}\n\n # test\n is_valid, errors = validate(data, 'bad_schema', validate_schema=True)\n\n # teardown\n os.remove(schema_file)\n os.removedirs(schema_dir)\n\n assert not is_valid\n assert errors","def testGetManifest(self):\n manifest = self.dl_object._GetManifest()\n self.assertEqual(manifest.get('mediaType'),\n 'application/vnd.docker.distribution.manifest.v2+json')\n self.assertIn('layers', manifest)","def require_manifest(func):\n\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n # Assume the manifest is in the current directory\n try:\n # If we are in a repository, we want to look in\n # the root of that repository for the manifest\n current_repo = vcs_git.RepoTool(Path.cwd(), search_parent=True)\n root_path = current_repo.get_root_path()\n except vcs_git.InvalidRepository:\n # Since we are not in a repository we will look\n # for the manifest in the current directory\n root_path = Path.cwd()\n\n manifest_path = root_path / manifest.MANIFEST_NAME\n\n try:\n loaded_manifest = manifest.load_manifest(manifest_path)\n return func(loaded_manifest, root_path, *args, **kwargs)\n except manifest.NotFound:\n ui.error(f\"Unable to load manifest: Not found: {str(manifest_path)}\")\n sys.exit(1)\n except manifest.ValidationFailed as exc:\n ui.error(f\"Unable to load manifest: Validation failed\")\n ui.error(str(exc))\n sys.exit(1)\n\n return wrapper","def is_manifest(location):\n return as_posixpath(location).lower().endswith('meta-inf/manifest.mf')","def test_required_term(self):\n schema = yaml.load(self.yaml_multiple_term, Loader=yaml.FullLoader)\n\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\n document = {'abundance': 'many'}\n val.validate(document)\n self.assertEqual(val.errors, {'eventDate': ['required field']})","def test_valid_and_empty_manifest(self):\n collector = PypiCollector()\n collector.parse_and_collect(MANIFEST_START + DEP_1, True)\n collector.parse_and_collect(None, True)\n packages = dict(collector.counter.most_common())\n assert packages == {\n 'daiquiri': 1\n }","async def validate(self):\n pass","def schema_validate_kubernetes_output(validate_data, cache_dir):\n (kind, version), validate_files = validate_data\n KubernetesManifestValidator(cache_dir).validate(validate_files, kind=kind, version=version)","def test_schema_version(self):\n\n self.validator.adata.uns[\"schema_version\"] = \"1.0.0\"\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors,\n [\n \"ERROR: Schema version '1.0.0' is not supported. Current supported versions: '['2.0.0']'. \"\n \"Validation cannot be performed.\"\n ],\n )","def test_is_valid_manifest_with_missing_url_column_and_error_on_empty_url(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_missing_url_column.tsv\",\n error_on_empty_url=True,\n )\n missing_size_message = (\n 'could not find a column name corresponding to required \"Columns.URL\"'\n )\n assert missing_size_message in caplog.text\n assert result == False","def test_validate_schema(schema_path):\n # Make sure that each schema itself is valid.\n schema_tree = schema.load_schema(schema_path, resolve_references=True)\n schema.check_schema(schema_tree)","def validateMain (self):\n self.mountMainPartition()\n sdMainValidity = self._getMainValidityMarker() \n sdMainValidity.markValid(self._getOscarVersionString())\n self._log(\"validate-main\").notice(\"main partition is validated\")","def test_is_valid_manifest_with_missing_url_column(caplog):\n logging.getLogger().setLevel(logging.WARNING)\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_missing_url_column.tsv\",\n )\n missing_size_message = (\n 'could not find a column name corresponding to required \"Columns.URL\"'\n )\n assert missing_size_message in caplog.text\n assert result == True","def validate_data(self, data):\n # TODO use schema\n assert \"file_contents\" in data, data\n assert \"type\" in data, data","def _validate_data(self, vms, fw_rules):\n self._validate_vms(vms)\n self._validate_fw_rules(fw_rules)\n self._validated = True","def validateMetadata(self, cur, hist):\n raise NotImplementedError(\"missing validateMetadata() method\")","def validate(self, args: argparse.Namespace) -> int:\n trestle_root = args.trestle_root # trestle root is set via command line in args. Default is cwd.\n\n # validate by type - all of type or just specified by name\n if 'type' in args and args.type is not None:\n models = []\n if 'name' in args and args.name is not None:\n models = [args.name]\n else:\n models = fs.get_models_of_type(args.type, trestle_root)\n models_path = trestle_root / fs.model_type_to_model_dir(args.type)\n for m in models:\n model_path = models_path / m\n try:\n _, _, model = load_distributed(model_path, trestle_root)\n except TrestleError as e:\n logger.warning(f'File load error {e}')\n return 1\n if not self.model_is_valid(model):\n logger.info(f'INVALID: Model {model_path} did not pass the {self.error_msg()}')\n return 1\n logger.info(f'VALID: Model {model_path} passed the {self.error_msg()}')\n return 0\n\n # validate all\n if 'all' in args and args.all:\n model_tups = fs.get_all_models(trestle_root)\n for mt in model_tups:\n\n model_dir = trestle_root / fs.model_type_to_model_dir(mt[0]) / mt[1]\n extension_type = fs.get_contextual_file_type(model_dir)\n model_path = model_dir / f'{mt[0]}{FileContentType.to_file_extension(extension_type)}'\n _, _, model = load_distributed(model_path, trestle_root)\n if not self.model_is_valid(model):\n logger.info(f'INVALID: Model {model_path} did not pass the {self.error_msg()}')\n return 1\n logger.info(f'VALID: Model {model_path} passed the {self.error_msg()}')\n return 0\n\n # validate file\n if 'file' in args and args.file:\n file_path = trestle_root / args.file\n _, _, model = load_distributed(file_path, trestle_root)\n if not self.model_is_valid(model):\n logger.info(f'INVALID: Model {file_path} did not pass the {self.error_msg()}')\n return 1\n logger.info(f'VALID: Model {file_path} passed the {self.error_msg()}')\n return 0","def Validate(self, relative_file, contents):\n pass","def validate_schema(self):\n\n _schema_translator = {\n 'dav': 'http',\n 'davs': 'https',\n }\n\n _logger.debug(\n \"[%s]Validating URN schema: %s\",\n self.id,\n self.uri['scheme']\n )\n\n if self.uri['scheme'] in _schema_translator:\n\n _logger.debug(\n \"[%s]Using URN schema: %s\",\n self.id,\n _schema_translator[self.uri['scheme']]\n )\n\n self.uri['scheme'] = _schema_translator[self.uri['scheme']]\n\n else:\n _logger.debug(\n \"[%s]Using URN schema: %s\",\n self.id,\n self.uri['scheme']\n )","def test_validators_meta_schemas(self):\n\n with self.assertWarns(DeprecationWarning) as w:\n value = validators.meta_schemas\n self.assertEqual(value, validators._META_SCHEMAS)\n\n self.assertEqual(w.filename, __file__)\n self.assertTrue(\n str(w.warning).startswith(\n \"Accessing asdf._jsonschema.validators.meta_schemas is deprecated\",\n ),\n )","def test_is_valid_manifest_format_using_error_on_empty_url(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_empty_url.tsv\",\n error_on_empty_url=True,\n )\n assert '\"\"' in caplog.text\n assert result == False","def validate_bagit_file(bagit_path):\n _assert_zip_file(bagit_path)\n bagit_zip = zipfile.ZipFile(bagit_path)\n manifest_info_list = _get_manifest_info_list(bagit_zip)\n _validate_checksums(bagit_zip, manifest_info_list)\n return True","def test_validate_invalid(self):\r\n self.assertEqual(get_tree_and_validate(self.invalid_xml, open(self.SCHEMA, 'r').read()), 0)","def load_validator_schema():\n logger.info('Loading validator schemas')\n SchemaLoader.load_all_from_path(validator_config_path)","def validate(self):\r\n return self.specs.validate(self)","def validate_schema_consistent(self, node):\n debug(\"validate_schema_consistent() \" + node.name)\n\n response = node.nodetool('describecluster', True)[0]\n schemas = response.split('Schema versions:')[1].strip()\n num_schemas = len(re.findall('\\[.*?\\]', schemas))\n assert num_schemas == 1, \"There were multiple schema versions: \" + pprint.pformat(schemas)"],"string":"[\n \"def validate_manifest(\\n request: ValidateManifestRequest = Body(...),\\n schema: Any = Depends(get_description_schema),\\n) -> ValidateManifestResponse:\\n\\n _, response = _validate_manifest(request, schema)\\n return response\",\n \"def validate_input_manifest(self, source, **kwargs):\\n return self._validate_manifest(\\\"input_manifest\\\", source, **kwargs)\",\n \"def check_manifest(manifest):\\n if not manifest:\\n raise Exception('manifest is null')\\n\\n for key in ['dublin_core', 'checking', 'projects']:\\n if key not in manifest:\\n raise Exception('manifest missing key \\\"{0}\\\"'.format(key))\\n\\n # check checking\\n for key in ['checking_entity', 'checking_level']:\\n if key not in manifest['checking']:\\n raise Exception('manifest missing checking key \\\"{0}\\\"'.format(key))\\n\\n if not isinstance(manifest['checking']['checking_entity'], list):\\n raise Exception('manifest key checking.checking_entity must be an array')\\n\\n # check projects\\n if not isinstance(manifest['projects'], list):\\n raise Exception('manifest key projects must be an array')\\n\\n for key in ['categories', 'identifier', 'path', 'sort', 'title', 'versification']:\\n for project in manifest['projects']:\\n if key not in project:\\n raise Exception('manifest missing project key \\\"{0}\\\"'.format(key))\\n\\n # check dublin_core\\n for key in ['conformsto', 'contributor', 'creator', 'description', 'format', 'identifier', 'issued', 'language',\\n 'modified', 'publisher', 'relation', 'rights', 'source', 'subject', 'title', 'type', 'version']:\\n if key not in manifest['dublin_core']:\\n raise Exception('manifest missing dublin_core key \\\"{0}\\\"'.format(key))\\n\\n expectedRCVersion = 'rc0.2'\\n if manifest['dublin_core']['conformsto'].lower() != expectedRCVersion:\\n raise Exception('unsupported rc version {}. Expected {}'.format(manifest['dublin_core']['conformsto'], expectedRCVersion))\\n\\n for key in ['direction', 'identifier', 'title']:\\n if key not in manifest['dublin_core']['language']:\\n raise Exception('manifest missing dublin_core.language key \\\"{0}\\\"'.format(key))\\n\\n if not isinstance(manifest['dublin_core']['source'], list):\\n raise Exception('manifest key dublin_core.source must be an array')\\n\\n for key in ['version', 'identifier', 'language']:\\n for source in manifest['dublin_core']['source']:\\n if key not in source:\\n raise Exception('manifest missing dublin_core.source key \\\"{0}\\\"'.format(key))\",\n \"def validate_manifest(parser, options):\\n if not options.manifest:\\n return\\n\\n template = \\\"When specifying --manifest, {0} is also required\\\"\\n\\n if not options.manifest_id:\\n parser.error(template.format(\\\"--manifest-id\\\"))\\n \\n if not options.manifest_service:\\n parser.error(template.format(\\\"--manifest-service\\\"))\\n\\n if not options.manifest_version:\\n parser.error(template.format(\\\"--manifest-version\\\"))\",\n \"def validate_manifest(manifest_json):\\n manifest_json = copy.deepcopy(manifest_json)\\n for field in [\\\"schemes\\\", \\\"host\\\", \\\"basePath\\\", \\\"info\\\"]:\\n if field not in manifest_json:\\n raise exceptions.ValidationError(\\n click.style(\\\"Field '{}' is missing from the manifest file.\\\", fg=\\\"red\\\").format(field),\\n json=manifest_json)\\n\\n for field in [\\\"contact\\\", \\\"title\\\", \\\"description\\\", \\\"x-21-total-price\\\", \\\"x-21-quick-buy\\\", \\\"x-21-category\\\"]:\\n if field not in manifest_json[\\\"info\\\"]:\\n raise exceptions.ValidationError(\\n click.style(\\n \\\"Field '{}' is missing from the manifest file under the 'info' section.\\\",\\n fg=\\\"red\\\").format(field),\\n json=manifest_json)\\n\\n for field in {\\\"name\\\", \\\"email\\\"}:\\n if field not in manifest_json[\\\"info\\\"][\\\"contact\\\"]:\\n raise exceptions.ValidationError(\\n click.style(\\n \\\"Field '{}' is missing from the manifest file under the 'contact' section.\\\", fg=\\\"red\\\")\\n .format(field),\\n json=manifest_json)\\n\\n for field in [\\\"min\\\", \\\"max\\\"]:\\n if field not in manifest_json[\\\"info\\\"][\\\"x-21-total-price\\\"]:\\n raise exceptions.ValidationError(\\n click.style(\\\"Field '{}' is missing from the manifest file under the \\\"\\n \\\"'x-21-total-price' section.\\\",\\n fg=\\\"red\\\"),\\n json=manifest_json)\\n\\n if len(manifest_json[\\\"schemes\\\"]) == 0:\\n raise exceptions.ValidationError(\\n click.style(\\n \\\"You have to specify either HTTP or HTTPS for your endpoint under the \\\"\\n \\\"`schemes` section.\\\",\\n fg=\\\"red\\\"),\\n json=manifest_json)\\n\\n valid_app_categories = {'blockchain', 'entertainment', 'social', 'markets', 'utilities', 'iot'}\\n if manifest_json[\\\"info\\\"][\\\"x-21-category\\\"].lower() not in valid_app_categories:\\n valid_categories = \\\", \\\".join(valid_app_categories)\\n raise exceptions.ValidationError(\\n click.style(\\\"'{}' is not a valid category for the 21 marketplace. Valid categories are {}.\\\",\\n fg=\\\"red\\\").format(\\n manifest_json[\\\"info\\\"][\\\"x-21-category\\\"], valid_categories),\\n json=manifest_json)\",\n \"def _validate(self):\\n All = voluptuous.All\\n Required = voluptuous.Required\\n Length = voluptuous.Length\\n Extra = voluptuous.Extra\\n\\n schema = voluptuous.Schema({\\n Required('description'): voluptuous.All(str, Length(min=5)),\\n Required('environments'): dict,\\n Required('application'): {\\n Required('name'): str,\\n Required('scenario'): [{\\n Required('driver'): str,\\n Required('description'): All(str, Length(min=5)),\\n Extra: object}]}})\\n try:\\n schema(self.marmite_tree)\\n except voluptuous.MultipleInvalid as e:\\n LOG.error(\\\"Failed to validate %s/marmite.yaml structure: %s\\\" %\\n (self.fs_layer.base_dir, e))\\n raise InvalidStructure()\",\n \"def validate_output_manifest(self, source, **kwargs):\\n return self._validate_manifest(\\\"output_manifest\\\", source, **kwargs)\",\n \"def test_is_valid_manifest_format_with_many_types_of_errors(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_many_types_of_errors.tsv\\\",\\n )\\n error_log = caplog.text\\n manifest_with_many_types_of_errors_helper(error_log)\\n assert result == False\",\n \"def validate(self):\\n import os\\n\\n if self.kind == KDM.INTEROP:\\n with open(os.path.join(os.path.dirname(__file__), 'xsd', 'interop.xsd'), 'r') as f:\\n schema = f.read()\\n elif self.kind == KDM.SMPTE:\\n with open(os.path.join(os.path.dirname(__file__), 'xsd', 'smpte.xsd'), 'r') as f:\\n schema = f.read()\\n\\n base_dir = os.getcwd()\\n os.chdir(os.path.join(os.path.dirname(__file__), 'xsd'))\\n try:\\n schema = ET.XMLSchema(ET.XML(schema))\\n xmlparser = ET.XMLParser(schema=schema)\\n ET.fromstring(self.raw, xmlparser)\\n finally:\\n os.chdir(base_dir)\",\n \"def _validate_all_expected_datasets_are_present_in_manifest(self, manifest_kind, manifest):\\n # This is the manifest schema included in the `twine.json` file, not the schema for `manifest.json` files.\\n manifest_schema = getattr(self, manifest_kind)\\n\\n for expected_dataset_name, expected_dataset_schema in manifest_schema[\\\"datasets\\\"].items():\\n if expected_dataset_name in manifest[\\\"datasets\\\"]:\\n continue\\n\\n if expected_dataset_schema.get(\\\"optional\\\", False):\\n continue\\n\\n raise exceptions.invalid_contents_map[manifest_kind](\\n f\\\"A dataset named {expected_dataset_name!r} is expected in the {manifest_kind} but is missing.\\\"\\n )\",\n \"def _validate(self):\\n if not self._contents.has_key('type'):\\n raise ValidationFailed(\\\"Metadata file %s contains no type field\\\" % (self._filename))\\n \\n if not self._contents.has_key('version'):\\n raise ValidationFailed(\\\"Metadata file %s contains no version field\\\" %\\n (self._filename))\",\n \"def metadata_validate(self):\\n # Set path to `service_schema` stored in the `resources` directory from cwd of `mpe_service.py`\\n current_path = Path(__file__).parent\\n relative_path = '../../snet/snet_cli/resources/service_schema'\\n path_to_schema = (current_path / relative_path).resolve()\\n with open(path_to_schema, 'r') as f:\\n schema = json.load(f)\\n metadata = load_mpe_service_metadata(self.args.metadata_file)\\n try:\\n validate(instance=metadata.m, schema=schema)\\n except Exception as e:\\n docs = \\\"http://snet-cli-docs.singularitynet.io/service.html\\\"\\n error_message = f\\\"\\\\nVisit {docs} for more information.\\\"\\n if e.validator == 'required':\\n raise ValidationError(e.message + error_message)\\n elif e.validator == 'minLength':\\n raise ValidationError(f\\\"`{e.path[-1]}` -> cannot be empty.\\\" + error_message)\\n elif e.validator == 'minItems':\\n raise ValidationError(f\\\"`{e.path[-1]}` -> minimum 1 item required.\\\" + error_message)\\n elif e.validator == 'type':\\n raise ValidationError(f\\\"`{e.path[-1]}` -> {e.message}\\\" + error_message)\\n elif e.validator == 'enum':\\n raise ValidationError(f\\\"`{e.path[-1]}` -> {e.message}\\\" + error_message)\\n elif e.validator == 'additionalProperties':\\n if len(e.path) != 0:\\n raise ValidationError(f\\\"{e.message} in `{e.path[-2]}`.\\\" + error_message)\\n else:\\n raise ValidationError(f\\\"{e.message} in main object.\\\" + error_message)\\n else:\\n exit(\\\"OK. Ready to publish.\\\")\",\n \"def _validate_against_schema(self, strand, data):\\n schema = self._get_schema(strand)\\n\\n try:\\n jsonschema_validate(instance=data, schema=schema)\\n logger.debug(\\\"Validated %s against schema\\\", strand)\\n\\n except ValidationError as e:\\n raise exceptions.invalid_contents_map[strand](str(e))\",\n \"def supports_manifest(manifest):\\n pass\",\n \"def test_validate_valid_resume(self):\\n # DEV: `validate` will raise an exception if it could not validate\\n self.assertIsNone(resumeschema.validate(self.valid_resume))\",\n \"def _validate(self):\\n schema_version = util.schemas[self.schema_name]\\n stored_schemas = util.stored_schemas\\n\\n try:\\n schema_obj = stored_schemas[\\n \\\"http://redfish.dmtf.org/schemas/v1/\\\" + schema_version]\\n except KeyError:\\n raise OneViewRedfishError(\\\"{} not found\\\".format(schema_version))\\n\\n resolver = jsonschema.RefResolver('', schema_obj, store=stored_schemas)\\n jsonschema.validate(self.redfish, schema_obj, resolver=resolver)\",\n \"def schema_check(self):\\n\\n try:\\n self.schema.assertValid(self.get_content())\\n except lxml.etree.DocumentInvalid:\\n logger.error(\\\"PDU failed schema check\\\")\\n for line in self.pretty_print_content().splitlines():\\n logger.warning(line)\\n raise\",\n \"def validate_full_schema(self):\\n #self.check_duplicate_labels()\\n for record in self.extension_schema['schema']['@graph']:\\n #self.check_whether_atid_and_label_match(record)\\n if record['@type'] == \\\"rdfs:Class\\\":\\n self.validate_class_schema(record)\\n #self.validate_class_label(record[\\\"@id\\\"])\\n self.validate_validation_field(record)\\n elif record['@type'] == \\\"rdf:Property\\\":\\n self.validate_property_schema(record)\\n #self.validate_property_label(record[\\\"@id\\\"])\\n #self.validate_domainIncludes_field(record[\\\"http://schema.org/domainIncludes\\\"])\\n #self.validate_rangeIncludes_field(record[\\\"http://schema.org/rangeIncludes\\\"])\\n #else:\\n # raise ValueError('wrong @type value found: {}'.format(record))\",\n \"def load_manifest(filename):\\n\\n data = manifest.load(filename)\\n for field in manifest.validate(data):\\n name = field.cfg or ''\\n if name and name[-1] != '.':\\n name += '>'\\n name += field.name\\n for msg in field.warnings:\\n print('WARNING: {}@{} {}'.format(filename, name, msg))\\n for msg in field.errors:\\n print('CRITICAL: {}@{} {}'.format(filename, name, msg))\\n return data\",\n \"def check_app_manifest(api_docs_path, overrides, marketplace):\\n if not os.path.exists(api_docs_path):\\n raise exceptions.ValidationError(\\n click.style(\\\"Could not find the manifest file at {}.\\\", fg=\\\"red\\\").format(api_docs_path))\\n\\n if os.path.isdir(api_docs_path):\\n raise exceptions.ValidationError(\\n click.style(\\\"{} is a directory. Please enter the direct path to the manifest file.\\\",\\n fg=\\\"red\\\").format(api_docs_path))\\n\\n file_size = os.path.getsize(api_docs_path) / 1e6\\n if file_size > 2:\\n raise exceptions.ValidationError(\\n click.style(\\\"The size of the manifest file at {} exceeds the maximum limit of 2MB.\\\", fg=\\\"red\\\")\\n .format(api_docs_path))\\n\\n try:\\n with open(api_docs_path, \\\"r\\\") as f:\\n original_manifest_dict = yaml.load(f.read())\\n\\n manifest_dict = transform_manifest(original_manifest_dict, overrides, marketplace)\\n\\n # write back the manifest in case some clean up or overriding has happend\\n with open(api_docs_path, \\\"w\\\") as f:\\n yaml.dump(manifest_dict, f)\\n\\n return manifest_dict\\n except (YAMLError, ValueError):\\n raise exceptions.ValidationError(\\n click.style(\\\"Your manifest file at {} is not valid YAML.\\\", fg=\\\"red\\\")\\n .format(api_docs_path))\",\n \"def readManifestFile(syn, manifestFile):\\n table.test_import_pandas()\\n import pandas as pd\\n\\n sys.stdout.write('Validation and upload of: %s\\\\n' % manifestFile)\\n # Read manifest file into pandas dataframe\\n df = pd.read_csv(manifestFile, sep='\\\\t')\\n if 'synapseStore' not in df:\\n df = df.assign(synapseStore=None)\\n df.synapseStore[df['path'].apply(is_url)] = False # override synapseStore values to False when path is a url\\n df.synapseStore[df['synapseStore'].isnull()] = True # remaining unset values default to True\\n df.synapseStore = df.synapseStore.astype(bool)\\n df = df.fillna('')\\n\\n sys.stdout.write('Validating columns of manifest...')\\n for field in REQUIRED_FIELDS:\\n sys.stdout.write('.')\\n if field not in df.columns:\\n sys.stdout.write('\\\\n')\\n raise ValueError(\\\"Manifest must contain a column of %s\\\" % field)\\n sys.stdout.write('OK\\\\n')\\n\\n sys.stdout.write('Validating that all paths exist')\\n df.path = df.path.apply(_check_path_and_normalize)\\n\\n sys.stdout.write('OK\\\\n')\\n\\n sys.stdout.write('Validating that all files are unique...')\\n if len(df.path) != len(set(df.path)):\\n raise ValueError(\\\"All rows in manifest must contain a unique file to upload\\\")\\n sys.stdout.write('OK\\\\n')\\n\\n sys.stdout.write('Validating provenance...')\\n df = _sortAndFixProvenance(syn, df)\\n sys.stdout.write('OK\\\\n')\\n\\n sys.stdout.write('Validating that parents exist and are containers...')\\n parents = set(df.parent)\\n for synId in parents:\\n try:\\n container = syn.get(synId, downloadFile=False)\\n except SynapseHTTPError:\\n sys.stdout.write('\\\\n%s in the parent column is not a valid Synapse Id\\\\n' % synId)\\n raise\\n if not is_container(container):\\n sys.stdout.write('\\\\n%s in the parent column is is not a Folder or Project\\\\n' % synId)\\n raise SynapseHTTPError\\n sys.stdout.write('OK\\\\n')\\n return df\",\n \"def validate(self):\\n print(\\\"Validating \\\")\\n sha256_test = _get_file_sha256_hash(self.file_path)\\n sha256_truth = self.metadata_pkg[\\\"hash\\\"]\\n if sha256_test != sha256_truth:\\n raise ValueError(\\n f\\\"Hash of modelpkg file {os.path.basename(self.file_path)} ({sha256_test}) does not match truth hash ({sha256_truth}).\\\")\",\n \"def test_validate_schema():\\n data = {\\n 'business': {\\n 'cacheId': 1,\\n 'foundingDate': '2007-04-08T00:00:00+00:00',\\n 'identifier': 'CP1234567',\\n 'legalName': 'legal name CP1234567'\\n },\\n }\\n\\n is_valid, _ = validate(data, 'business', validate_schema=True)\\n\\n assert is_valid\",\n \"def validate_configuration_manifest(self, source, **kwargs):\\n return self._validate_manifest(\\\"configuration_manifest\\\", source, **kwargs)\",\n \"def schema_valid(arch, **kwargs):\\n validator = relaxng(arch.tag)\\n if validator and not validator.validate(arch):\\n result = True\\n for error in validator.error_log:\\n _logger.error(tools.ustr(error))\\n result = False\\n return result\\n return True\",\n \"def validate(self, schema=os.path.join(os.path.dirname(__file__), 'am.xsd')):\\n return validate_xml(schema, self.path, from_path=True)\",\n \"def test_check_presence_only(self):\\n schema = yaml.load(self.yaml_presence_check, Loader=yaml.FullLoader)\\n val = DwcaValidator(schema, allow_unknown=True,\\n error_handler=WhipErrorHandler)\\n\\n document = {'abundance': 'many'}\\n self.assertTrue(val.validate(document))\\n document = {'abundance': ''}\\n self.assertTrue(val.validate(document))\\n document = {'eventDate': ''}\\n val.validate(document)\\n self.assertEqual(val.errors, {})\",\n \"def _validate_yaml(self):\\n\\n # verify the format is correct\\n if self.validater == 'yamale':\\n\\n import yamale\\n\\n print('Validating yaml file with yamale.')\\n cwd = Path(os.path.dirname(__file__))\\n schema_path = str(cwd.parent / 'schema') + '/generic_schema.yaml'\\n schema = yamale.make_schema(schema_path)\\n data = yamale.make_data(self.yaml_path)\\n try:\\n yamale.validate(schema, data, strict=False)\\n print('Validation success! 👍')\\n return True\\n except ValueError as e:\\n print(\\n 'Yamale found that your file, '\\n + self.yaml_path\\n + ' is not formatted correctly.'\\n )\\n print(e)\\n return False\\n else:\\n print('Did not validate yaml.')\\n print('If unexpected results occur, try installing yamale and rerun.')\\n return True\",\n \"def test_is_valid_manifest_format_with_invalid_sizes(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_invalid_sizes.tsv\\\"\\n )\\n error_log = caplog.text\\n assert \\\"-1\\\" in error_log\\n assert \\\"not_an_int\\\" in error_log\\n assert \\\"3.34\\\" in error_log\\n assert \\\"string_with_42\\\" in error_log\\n assert result == False\",\n \"def check_valid_schema(context):\\n data = context.response.json()\\n validate_schema(data)\",\n \"def test_is_valid_valid_resume(self):\\n self.assertTrue(resumeschema.is_valid(self.valid_resume))\",\n \"def test_is_valid_manifest_format_with_no_errors(caplog):\\n assert (\\n is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_no_errors.tsv\\\"\\n )\\n == True\\n )\\n assert caplog.text == \\\"\\\"\",\n \"def validate_schema(self, schema):\\n json_schema_path = os.path.join(_ROOT, 'data', 'schema.json')\\n json_schema = load_json_or_yaml(json_schema_path)\\n return validate(schema, json_schema)\",\n \"def _validate_twine_version(self, twine_file_twined_version):\\n installed_twined_version = pkg_resources.get_distribution(\\\"twined\\\").version\\n logger.debug(\\n \\\"Twine versions... %s installed, %s specified in twine\\\", installed_twined_version, twine_file_twined_version\\n )\\n if (twine_file_twined_version is not None) and (installed_twined_version != twine_file_twined_version):\\n raise exceptions.TwineVersionConflict(\\n f\\\"Twined library version conflict. Twine file requires {twine_file_twined_version} but you have {installed_twined_version} installed\\\"\\n )\",\n \"def test_schema_valid(path, name, data):\\n schemas = metaschemas()\\n if name in ('release-schema.json', 'release-package-schema.json'):\\n metaschema = schemas['release_package_metaschema']\\n elif name == 'record-package-schema.json':\\n metaschema = schemas['record_package_metaschema']\\n elif name in ('project-schema.json', 'project-package-schema.json'):\\n metaschema = schemas['project_package_metaschema']\\n else:\\n metaschema = schemas['metaschema']\\n\\n validate_json_schema(path, name, data, metaschema)\",\n \"def validate_metadata(self, metadata: Dict[str, dict]):\\n encoder = NWBMetaDataEncoder()\\n # The encoder produces a serialiazed object so we de serialized it for comparison\\n serialized_metadata = encoder.encode(metadata)\\n decoded_metadata = json.loads(serialized_metadata)\\n validate(instance=decoded_metadata, schema=self.get_metadata_schema())\\n if self.verbose:\\n print(\\\"Metadata is valid!\\\")\",\n \"def validate(args):\\n args = {k.lstrip('-').lower().replace('-', '_'): v\\n for k, v in args.items()}\\n schema = Schema({\\n 'ptvsd': Or(None, And(Use(int), lambda port: 1 <= port <= 65535)),\\n 'root_dir': os.path.exists,\\n 'resume': bool,\\n })\\n args = schema.validate(args)\\n return args\",\n \"def validate(self, namespace):\\n pass\",\n \"def test_is_valid_manifest_with_wide_row(caplog):\\n logging.getLogger().setLevel(logging.WARNING)\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_wide_row.tsv\\\",\\n )\\n wide_warning = f\\\"line 3, number of fields (6) in row is unequal to number of column names in manifest (5)\\\"\\n assert wide_warning in caplog.text\\n assert result == True\",\n \"def test_is_valid_invalid_resume(self):\\n self.assertFalse(resumeschema.is_valid(self.invalid_resume))\",\n \"def app_validate(data):\\n\\n schema = json.load(open('schemas/app_description_schema.json', 'r'))\\n try:\\n jsonschema.validate(data, schema)\\n except jsonschema.ValidationError as e:\\n raise InvalidApplicationDescription(str(e))\\n except jsonschema.SchemaError:\\n log.exception('BUG: invalid schema for application descriptions')\\n raise ZoeLibException('BUG: invalid schema for application descriptions')\\n\\n # Start non-schema, semantic checks\\n if data['version'] != zoe_lib.version.ZOE_APPLICATION_FORMAT_VERSION:\\n raise InvalidApplicationDescription('Application description version mismatch (expected: {}, found: {}'.format(zoe_lib.version.ZOE_APPLICATION_FORMAT_VERSION, data['version']))\\n\\n found_monitor = False\\n for service in data['services']:\\n if service['monitor']:\\n found_monitor = True\\n\\n service['resources']['memory']['max'] = zoe_lib.config.get_conf().max_memory_limit * (1024 ** 3)\\n if service['resources']['memory']['min'] is not None and service['resources']['memory']['min'] > service['resources']['memory']['max']:\\n raise InvalidApplicationDescription(msg='service {} tries to reserve more memory than the administrative limit'.format(service['name']))\\n\\n if service['resources']['cores']['min'] is None:\\n service['resources']['cores']['min'] = 0.1\\n\\n if not found_monitor:\\n raise InvalidApplicationDescription(msg=\\\"at least one process should have the monitor property set to true\\\")\",\n \"def test_validate_invalid_resume(self):\\n # DEV: `validate` will raise an exception if it could not validate\\n with self.assertRaises(jsonschema.ValidationError):\\n resumeschema.validate(self.invalid_resume)\",\n \"def isValidForSchema(schema):\\n\\n return True\",\n \"def validate_payload(cls, event):\\n # TODO: Use invenio-jsonschemas/jsonresolver instead of this\\n # Validate against Event JSONSchema\\n # NOTE: raises `jsonschemas.ValidationError`\\n cls._jsonschema_validator.validate(event)\\n\\n # Validate using marshmallow loader\\n for payload in event:\\n errors = RelationshipSchema(check_existing=True).validate(payload)\\n if errors:\\n raise MarshmallowValidationError(str(errors) + \\\"payload\\\" + str(payload))\",\n \"def validate(entry: _LexiconEntry) -> None:\\n _entry_has_required_fields(entry)\\n _entry_field_values_are_not_empty(entry)\\n _entry_field_values_does_not_contain_infix_whitespace(entry)\\n _entry_tag_is_valid(entry)\\n _entry_compound_annotation_is_valid(entry)\\n _entry_morphophonemics_annotation_is_valid(entry)\\n _entry_features_annotation_is_valid(entry)\\n _entry_has_required_features(entry)\\n _entry_required_features_are_valid(entry)\\n _entry_optional_features_are_valid(entry)\\n _entry_features_are_not_redundant(entry)\",\n \"def test_invalid_manifest_filepath(self):\\n load_manifest(\\\"./ehiiehaiehnatheita\\\")\",\n \"def test_theme_manifest(err, xpi_package=None):\\n\\n # Don't even both with the test(s) if there's no chrome.manifest.\\n chrome = err.get_resource('chrome.manifest')\\n if not chrome:\\n return\\n\\n for triple in chrome.triples:\\n subject = triple['subject']\\n # Test to make sure that the triple's subject is valid\\n if subject not in ('skin', 'style'):\\n err.warning(\\n err_id=('themes', 'test_theme_manifest',\\n 'invalid_chrome_manifest_subject'),\\n warning='Invalid chrome.manifest subject',\\n description=('chrome.manifest files for full themes are only '\\n \\\"allowed to have 'skin' and 'style' items. \\\"\\n 'Other types of items are disallowed for '\\n 'security reasons.',\\n 'Invalid subject: %s' % subject),\\n filename=triple['filename'],\\n line=triple['line'],\\n context=triple['context'])\",\n \"def test_admin_freeze_schema():\\n legal_filing = {'adminFreeze': ADMIN_FREEZE}\\n\\n is_valid, errors = validate(legal_filing, 'admin_freeze')\\n\\n if errors:\\n for err in errors:\\n print(err.message)\\n print(errors)\\n\\n assert is_valid\",\n \"def validate():\",\n \"def test_is_valid_manifest_format_using_line_limit(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_invalid_sizes.tsv\\\",\\n line_limit=3,\\n )\\n error_log = caplog.text\\n assert \\\"line 2\\\" in error_log\\n assert \\\"line 3\\\" in error_log\\n assert \\\"line 4\\\" not in error_log\\n assert \\\"line 5\\\" not in error_log\\n assert result == False\",\n \"def test_is_valid_manifest_with_missing_size_column(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_missing_size_column.tsv\\\",\\n )\\n missing_size_message = (\\n 'could not find a column name corresponding to required \\\"Columns.SIZE\\\"'\\n )\\n assert missing_size_message in caplog.text\\n assert result == False\",\n \"def _validate_yaml(schema, config):\\n check = pykwalify_core.Core(\\n source_data=config, schema_files=[\\\"{}/{}.yml\\\".format(conf_schema_path, schema)])\\n try:\\n check.validate(raise_exception=True)\\n except pykwalify_errors.SchemaError as e:\\n _logger.error(\\\"Schema validation failed\\\")\\n raise Exception(\\\"File does not conform to {} schema: {}\\\".format(schema, e))\",\n \"def test_sa_mismatch_manifest_file_and_ecosystem(self):\\n with open(str(Path(__file__).parent.parent.parent) +\\n '/data/manifests/202/npmlist.json', 'rb') as fp:\\n fs = FileStorage(stream=fp, filename='npmlist.json')\\n with pytest.raises(Exception) as exception:\\n sa_post_request = StackAnalysesPostRequest(manifest=fs, file_path='/tmp/bin',\\n ecosystem='pypi', show_transitive=True)\\n sa = StackAnalyses(sa_post_request)\\n sa.post_request()\\n self.assertIs(exception.type, ValidationError)\",\n \"def test_is_valid_manifest_format_with_invalid_md5_values(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_invalid_md5_values.tsv\\\"\\n )\\n\\n error_log = caplog.text\\n manifest_with_invalid_md5_values_helper(error_log)\\n base64_encoded_md5 = '\\\"jd2L5LF5pSmvpfL/rkuYWA==\\\"'\\n assert base64_encoded_md5 in error_log\\n assert result == False\",\n \"def is_manifest_list(self):\\n return False\",\n \"def validate():\\n description = f\\\"Validate XML metadata.\\\"\\n parser = argparse.ArgumentParser(\\n description=description,\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter\\n )\\n\\n help = \\\"XML file or URL\\\"\\n parser.add_argument('infile', help=help)\\n\\n help = (\\n \\\"Format ID for metadata standard. If this argument is supplied, \\\"\\n \\\"only that format ID will be checked. If not, all format IDs will be \\\"\\n \\\"checked.\\\"\\n )\\n parser.add_argument('--format-id',\\n help=help,\\n choices=d1_scimeta.util.get_supported_format_id_list())\\n\\n help = \\\"Verbosity of log messages.\\\"\\n choices = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']\\n parser.add_argument('-v', '--verbosity', help=help, choices=choices,\\n default='INFO')\\n\\n args = parser.parse_args()\\n\\n validator = XMLValidator(verbosity=args.verbosity)\\n validator.validate(args.infile, format_id=args.format_id)\",\n \"def read_manifest(self): # -> None:\\n ...\",\n \"def _validate_against_schema(config):\\n logging.info(\\\"Validating config file against the schema\\\")\\n try:\\n c = Core(source_data=config, schema_files=[CONFIG_SCHEMA])\\n c.validate(raise_exception=True)\\n except Exception as e:\\n logging.error(\\\"Failed when validating schema: %s\\\", e)\\n logging.info(\\\"Dumping rendered template:\\\\n%s\\\", dump_rendered_config_file(config))\\n raise\",\n \"def validateBoot (self):\\n self.mountBootPartition()\\n stateDictionary = self._createBootInstallationDictionary()\\n self._writeDictionaryAsJson(stateDictionary, self._getBootInstallationFilePath())\\n self._log(\\\"validate-boot\\\").notice(\\\"boot partition is validated\\\")\",\n \"def test_required_fields_schema_version(self):\\n\\n del self.validator.adata.uns[\\\"schema_version\\\"]\\n self.validator.validate_adata()\\n self.assertEqual(\\n self.validator.errors,\\n [\\n \\\"ERROR: adata has no schema definition in 'adata.uns'. \\\"\\n \\\"Validation cannot be performed.\\\"\\n ],\\n )\",\n \"def validate_data(self, deployment='ops'):\\n self.validator.set_example(self.example)\\n\\n # Don't just use the built in validate_data method as this needs to be future proofed against C100 firmware\\n # upgrades. This upgrade will result in a new mode SELAP (R...CNTL2MODE == 64).\\n self.validator.validate_capture_file_counts()\\n self.validator.validate_capture_file_waveforms()\\n\\n # Many of these examples will have some amount of rounding error.\\n self.validator.validate_waveform_times(min_end=10.0, max_start=-1534.0, step_size=0.2)\\n self.validator.validate_cavity_modes(mode=(4, 64), deployment=deployment)\\n self.validator.validate_zones()\",\n \"def validate_schema(self):\\n for _, certificate in self.certificates_to_issue.items():\\n with open(certificate.signed_cert_file_name) as cert:\\n cert_json = json.load(cert)\\n validate_unsigned_v1_2(cert_json)\",\n \"def validate(self):\\n with open(os.path.join(settings.MEDIA_ROOT, self.file.name)) as file:\\n lines = file.readlines()\\n validators = ['os.', 'from os', 'io.', 'from io', 'open(', 'system(']\\n for line in lines:\\n for validator in validators:\\n if validator in line:\\n return False\\n return True\",\n \"def test_validate_business_schema():\\n data = {\\n 'business': {\\n 'cacheId': 1,\\n 'foundingDate': '2007-04-08T00:00:00+00:00',\\n 'identifier': 'CP1234567',\\n 'lastLedgerTimestamp': '2019-04-15T20:05:49.068272+00:00',\\n 'lastPreBobFilingTimestamp': '2019-04-15T20:05:49.068272+00:00',\\n 'legalName': 'legal name - CP1234567'\\n },\\n }\\n\\n is_valid, _ = validate(data, 'business', validate_schema=True)\\n\\n assert is_valid\",\n \"def validate_available(parser, options):\\n if not options.available:\\n return\\n\\n if not options.manifest_id:\\n parser.error(\\\"When specifying --available, --manifest-id is also required\\\")\",\n \"def validate(self) -> bool:\\n\\n # Start by reading in the blueprint schema json\\n schema = json.loads(pkgutil.get_data(\\\"FactorioTools\\\", \\\"blueprintSchema.json\\\"))\\n\\n # Validate the object's schema against the blueprintSchema JSON\\n try:\\n jsonschema.validate(self.data, schema)\\n return True\\n except jsonschema.ValidationError:\\n pass\\n\\n return False\",\n \"def semantic_validate(instance):\\n unknown_templates = {}\\n for name, requires in instance[\\\"application\\\"][\\\"requires\\\"].items():\\n if name in instance[\\\"application\\\"][\\\"services\\\"]:\\n raise ValidationError(errors=[\\n \\\"/application/requires/{}: the name {} conflicts with service\\\"\\n \\\" /application/services/{}\\\".format(name,\\n repr(name),\\n name),\\n ])\\n if requires[\\\"template\\\"] not in instance[\\\"local\\\"][\\\"templates\\\"]:\\n unknown_templates[\\\"/application/requires/{}/template\\\".format(\\n name)] = requires[\\\"template\\\"]\\n for service_name, service in instance[\\\"application\\\"][\\\"services\\\"].items():\\n for name, requires in service[\\\"requires\\\"].items():\\n if name in instance[\\\"application\\\"][\\\"requires\\\"]:\\n raise ValidationError(errors=[\\n \\\"/application/services/{}/requires/{}: the name {}\\\"\\n \\\" conflicts with /application/requires/{}\\\".format(\\n service_name, name, repr(name), name)\\n ])\\n if requires[\\\"template\\\"] not in instance[\\\"local\\\"][\\\"templates\\\"]:\\n unknown_templates[\\n \\\"/application/services/{}/requires/{}/template\\\".\\n format(service_name, name)] = requires[\\\"template\\\"]\\n if unknown_templates:\\n raise ValidationError(errors=[\\n \\\"{}: the template {} does not exist \\\"\\n \\\"in /local/templates\\\".format(path, repr(name))\\n for (path, name) in unknown_templates.items()\\n ])\",\n \"def test_sa_invalid_manifest_file(self):\\n with open(str(Path(__file__).parent.parent.parent) +\\n '/data/manifests/400/npmlist.json', 'rb') as fp:\\n fs = FileStorage(stream=fp, filename='npmlist.json')\\n sa_post_request = StackAnalysesPostRequest(manifest=fs, file_path='/tmp/bin',\\n ecosystem='npm', show_transitive=True)\\n sa = StackAnalyses(sa_post_request)\\n with pytest.raises(Exception) as exception:\\n sa.post_request()\\n self.assertIs(exception.type, SAInvalidInputException)\",\n \"def validate(self):\\n return _libsbml.SBMLExternalValidator_validate(self)\",\n \"def test_is_valid_manifest_with_missing_md5_column(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_missing_md5_column.tsv\\\",\\n )\\n missing_md5_message = (\\n 'could not find a column name corresponding to required \\\"Columns.MD5\\\"'\\n )\\n assert missing_md5_message in caplog.text\\n assert result == False\",\n \"def validate(self):\\n allowed_backbones = ['resnet50', 'resnet101', 'resnet152']\\n backbone = self.backbone.split('_')[0]\\n\\n if backbone not in allowed_backbones:\\n raise ValueError('Backbone (\\\\'{}\\\\') not in allowed backbones ({}).'.format(backbone, allowed_backbones))\",\n \"def test_manifest(self):\\n self.parse_manifest()\\n\\n ids = {}\\n errors = []\\n collisions = []\\n manifest = self.cryptomattes[self.selection][\\\"names_to_IDs\\\"]\\n for name, idvalue in manifest.iteritems():\\n if mm3hash_float(name) != idvalue:\\n errors.append(\\\"computed ID doesn't match manifest ID: (%s, %s)\\\" % (idvalue, mm3hash_float(name)))\\n else:\\n if idvalue in ids:\\n collisions.append(\\\"colliding: %s %s\\\" % (ids[idvalue], name))\\n ids[idvalue] = name\\n\\n print \\\"Tested %s, %s names\\\" % (self.nuke_node.name(), len(manifest))\\n print \\\" \\\", len(errors), \\\"non-matching IDs between python and c++.\\\"\\n print \\\" \\\", len(collisions), \\\"hash collisions in manifest.\\\"\\n\\n return errors, collisions\",\n \"def test_is_valid_manifest_format_with_invalid_authz_resources(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_invalid_authz_resources.tsv\\\",\\n )\\n error_log = caplog.text\\n assert '\\\"invalid_authz\\\"' in error_log\\n assert '\\\"/\\\"' in error_log\\n assert '\\\"//\\\"' in error_log\\n assert '\\\"///\\\"' in error_log\\n assert '\\\"invalid_authz2\\\"' in error_log\\n assert result == False\",\n \"def __validate():\\n # TODO: implement\",\n \"def test_invalid_schema():\\n # setup\\n uid = uuid.uuid4()\\n schema_dir = f'/tmp/{uid}'\\n schema_file = f'{schema_dir}/bad_schema.json'\\n os.makedirs(schema_dir)\\n text_file = open(schema_file, 'w')\\n text_file.write('this will fail[];fail()')\\n text_file.close()\\n\\n data = {}\\n\\n # test\\n is_valid, errors = validate(data, 'bad_schema', validate_schema=True)\\n\\n # teardown\\n os.remove(schema_file)\\n os.removedirs(schema_dir)\\n\\n assert not is_valid\\n assert errors\",\n \"def testGetManifest(self):\\n manifest = self.dl_object._GetManifest()\\n self.assertEqual(manifest.get('mediaType'),\\n 'application/vnd.docker.distribution.manifest.v2+json')\\n self.assertIn('layers', manifest)\",\n \"def require_manifest(func):\\n\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n # Assume the manifest is in the current directory\\n try:\\n # If we are in a repository, we want to look in\\n # the root of that repository for the manifest\\n current_repo = vcs_git.RepoTool(Path.cwd(), search_parent=True)\\n root_path = current_repo.get_root_path()\\n except vcs_git.InvalidRepository:\\n # Since we are not in a repository we will look\\n # for the manifest in the current directory\\n root_path = Path.cwd()\\n\\n manifest_path = root_path / manifest.MANIFEST_NAME\\n\\n try:\\n loaded_manifest = manifest.load_manifest(manifest_path)\\n return func(loaded_manifest, root_path, *args, **kwargs)\\n except manifest.NotFound:\\n ui.error(f\\\"Unable to load manifest: Not found: {str(manifest_path)}\\\")\\n sys.exit(1)\\n except manifest.ValidationFailed as exc:\\n ui.error(f\\\"Unable to load manifest: Validation failed\\\")\\n ui.error(str(exc))\\n sys.exit(1)\\n\\n return wrapper\",\n \"def is_manifest(location):\\n return as_posixpath(location).lower().endswith('meta-inf/manifest.mf')\",\n \"def test_required_term(self):\\n schema = yaml.load(self.yaml_multiple_term, Loader=yaml.FullLoader)\\n\\n val = DwcaValidator(schema, error_handler=WhipErrorHandler)\\n document = {'abundance': 'many'}\\n val.validate(document)\\n self.assertEqual(val.errors, {'eventDate': ['required field']})\",\n \"def test_valid_and_empty_manifest(self):\\n collector = PypiCollector()\\n collector.parse_and_collect(MANIFEST_START + DEP_1, True)\\n collector.parse_and_collect(None, True)\\n packages = dict(collector.counter.most_common())\\n assert packages == {\\n 'daiquiri': 1\\n }\",\n \"async def validate(self):\\n pass\",\n \"def schema_validate_kubernetes_output(validate_data, cache_dir):\\n (kind, version), validate_files = validate_data\\n KubernetesManifestValidator(cache_dir).validate(validate_files, kind=kind, version=version)\",\n \"def test_schema_version(self):\\n\\n self.validator.adata.uns[\\\"schema_version\\\"] = \\\"1.0.0\\\"\\n self.validator.validate_adata()\\n self.assertEqual(\\n self.validator.errors,\\n [\\n \\\"ERROR: Schema version '1.0.0' is not supported. Current supported versions: '['2.0.0']'. \\\"\\n \\\"Validation cannot be performed.\\\"\\n ],\\n )\",\n \"def test_is_valid_manifest_with_missing_url_column_and_error_on_empty_url(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_missing_url_column.tsv\\\",\\n error_on_empty_url=True,\\n )\\n missing_size_message = (\\n 'could not find a column name corresponding to required \\\"Columns.URL\\\"'\\n )\\n assert missing_size_message in caplog.text\\n assert result == False\",\n \"def test_validate_schema(schema_path):\\n # Make sure that each schema itself is valid.\\n schema_tree = schema.load_schema(schema_path, resolve_references=True)\\n schema.check_schema(schema_tree)\",\n \"def validateMain (self):\\n self.mountMainPartition()\\n sdMainValidity = self._getMainValidityMarker() \\n sdMainValidity.markValid(self._getOscarVersionString())\\n self._log(\\\"validate-main\\\").notice(\\\"main partition is validated\\\")\",\n \"def test_is_valid_manifest_with_missing_url_column(caplog):\\n logging.getLogger().setLevel(logging.WARNING)\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_missing_url_column.tsv\\\",\\n )\\n missing_size_message = (\\n 'could not find a column name corresponding to required \\\"Columns.URL\\\"'\\n )\\n assert missing_size_message in caplog.text\\n assert result == True\",\n \"def validate_data(self, data):\\n # TODO use schema\\n assert \\\"file_contents\\\" in data, data\\n assert \\\"type\\\" in data, data\",\n \"def _validate_data(self, vms, fw_rules):\\n self._validate_vms(vms)\\n self._validate_fw_rules(fw_rules)\\n self._validated = True\",\n \"def validateMetadata(self, cur, hist):\\n raise NotImplementedError(\\\"missing validateMetadata() method\\\")\",\n \"def validate(self, args: argparse.Namespace) -> int:\\n trestle_root = args.trestle_root # trestle root is set via command line in args. Default is cwd.\\n\\n # validate by type - all of type or just specified by name\\n if 'type' in args and args.type is not None:\\n models = []\\n if 'name' in args and args.name is not None:\\n models = [args.name]\\n else:\\n models = fs.get_models_of_type(args.type, trestle_root)\\n models_path = trestle_root / fs.model_type_to_model_dir(args.type)\\n for m in models:\\n model_path = models_path / m\\n try:\\n _, _, model = load_distributed(model_path, trestle_root)\\n except TrestleError as e:\\n logger.warning(f'File load error {e}')\\n return 1\\n if not self.model_is_valid(model):\\n logger.info(f'INVALID: Model {model_path} did not pass the {self.error_msg()}')\\n return 1\\n logger.info(f'VALID: Model {model_path} passed the {self.error_msg()}')\\n return 0\\n\\n # validate all\\n if 'all' in args and args.all:\\n model_tups = fs.get_all_models(trestle_root)\\n for mt in model_tups:\\n\\n model_dir = trestle_root / fs.model_type_to_model_dir(mt[0]) / mt[1]\\n extension_type = fs.get_contextual_file_type(model_dir)\\n model_path = model_dir / f'{mt[0]}{FileContentType.to_file_extension(extension_type)}'\\n _, _, model = load_distributed(model_path, trestle_root)\\n if not self.model_is_valid(model):\\n logger.info(f'INVALID: Model {model_path} did not pass the {self.error_msg()}')\\n return 1\\n logger.info(f'VALID: Model {model_path} passed the {self.error_msg()}')\\n return 0\\n\\n # validate file\\n if 'file' in args and args.file:\\n file_path = trestle_root / args.file\\n _, _, model = load_distributed(file_path, trestle_root)\\n if not self.model_is_valid(model):\\n logger.info(f'INVALID: Model {file_path} did not pass the {self.error_msg()}')\\n return 1\\n logger.info(f'VALID: Model {file_path} passed the {self.error_msg()}')\\n return 0\",\n \"def Validate(self, relative_file, contents):\\n pass\",\n \"def validate_schema(self):\\n\\n _schema_translator = {\\n 'dav': 'http',\\n 'davs': 'https',\\n }\\n\\n _logger.debug(\\n \\\"[%s]Validating URN schema: %s\\\",\\n self.id,\\n self.uri['scheme']\\n )\\n\\n if self.uri['scheme'] in _schema_translator:\\n\\n _logger.debug(\\n \\\"[%s]Using URN schema: %s\\\",\\n self.id,\\n _schema_translator[self.uri['scheme']]\\n )\\n\\n self.uri['scheme'] = _schema_translator[self.uri['scheme']]\\n\\n else:\\n _logger.debug(\\n \\\"[%s]Using URN schema: %s\\\",\\n self.id,\\n self.uri['scheme']\\n )\",\n \"def test_validators_meta_schemas(self):\\n\\n with self.assertWarns(DeprecationWarning) as w:\\n value = validators.meta_schemas\\n self.assertEqual(value, validators._META_SCHEMAS)\\n\\n self.assertEqual(w.filename, __file__)\\n self.assertTrue(\\n str(w.warning).startswith(\\n \\\"Accessing asdf._jsonschema.validators.meta_schemas is deprecated\\\",\\n ),\\n )\",\n \"def test_is_valid_manifest_format_using_error_on_empty_url(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_empty_url.tsv\\\",\\n error_on_empty_url=True,\\n )\\n assert '\\\"\\\"' in caplog.text\\n assert result == False\",\n \"def validate_bagit_file(bagit_path):\\n _assert_zip_file(bagit_path)\\n bagit_zip = zipfile.ZipFile(bagit_path)\\n manifest_info_list = _get_manifest_info_list(bagit_zip)\\n _validate_checksums(bagit_zip, manifest_info_list)\\n return True\",\n \"def test_validate_invalid(self):\\r\\n self.assertEqual(get_tree_and_validate(self.invalid_xml, open(self.SCHEMA, 'r').read()), 0)\",\n \"def load_validator_schema():\\n logger.info('Loading validator schemas')\\n SchemaLoader.load_all_from_path(validator_config_path)\",\n \"def validate(self):\\r\\n return self.specs.validate(self)\",\n \"def validate_schema_consistent(self, node):\\n debug(\\\"validate_schema_consistent() \\\" + node.name)\\n\\n response = node.nodetool('describecluster', True)[0]\\n schemas = response.split('Schema versions:')[1].strip()\\n num_schemas = len(re.findall('\\\\[.*?\\\\]', schemas))\\n assert num_schemas == 1, \\\"There were multiple schema versions: \\\" + pprint.pformat(schemas)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70706165","0.67949265","0.6726037","0.6626515","0.6575376","0.650649","0.6169406","0.6119033","0.6040567","0.59697014","0.59644884","0.59519655","0.5935721","0.591002","0.5886837","0.58650386","0.5852848","0.5783439","0.5762712","0.5759838","0.5739801","0.57347035","0.5726784","0.5710004","0.5693958","0.5693534","0.5673112","0.56656915","0.56504315","0.5649177","0.5633841","0.56313825","0.56237936","0.56111836","0.560569","0.5600829","0.55967593","0.5590038","0.5589815","0.55742365","0.55581766","0.55367655","0.553094","0.55308384","0.5528924","0.55285746","0.5517953","0.55127114","0.5511322","0.5510334","0.54839706","0.5457767","0.5457429","0.5441134","0.5440951","0.5440062","0.53989565","0.5391574","0.53773606","0.5367243","0.5364569","0.53270596","0.5309413","0.5289387","0.5285121","0.5281236","0.5279765","0.5275161","0.52578974","0.52578956","0.52507865","0.52462655","0.524545","0.5240002","0.5238868","0.5228455","0.5219578","0.5213035","0.5201603","0.51988834","0.519841","0.51963055","0.51918846","0.5188026","0.5181621","0.51804537","0.5174792","0.5173135","0.5172104","0.51489264","0.51478297","0.514756","0.5140056","0.513984","0.51387894","0.51375234","0.5135871","0.5135654","0.51249135","0.51189345"],"string":"[\n \"0.70706165\",\n \"0.67949265\",\n \"0.6726037\",\n \"0.6626515\",\n \"0.6575376\",\n \"0.650649\",\n \"0.6169406\",\n \"0.6119033\",\n \"0.6040567\",\n \"0.59697014\",\n \"0.59644884\",\n \"0.59519655\",\n \"0.5935721\",\n \"0.591002\",\n \"0.5886837\",\n \"0.58650386\",\n \"0.5852848\",\n \"0.5783439\",\n \"0.5762712\",\n \"0.5759838\",\n \"0.5739801\",\n \"0.57347035\",\n \"0.5726784\",\n \"0.5710004\",\n \"0.5693958\",\n \"0.5693534\",\n \"0.5673112\",\n \"0.56656915\",\n \"0.56504315\",\n \"0.5649177\",\n \"0.5633841\",\n \"0.56313825\",\n \"0.56237936\",\n \"0.56111836\",\n \"0.560569\",\n \"0.5600829\",\n \"0.55967593\",\n \"0.5590038\",\n \"0.5589815\",\n \"0.55742365\",\n \"0.55581766\",\n \"0.55367655\",\n \"0.553094\",\n \"0.55308384\",\n \"0.5528924\",\n \"0.55285746\",\n \"0.5517953\",\n \"0.55127114\",\n \"0.5511322\",\n \"0.5510334\",\n \"0.54839706\",\n \"0.5457767\",\n \"0.5457429\",\n \"0.5441134\",\n \"0.5440951\",\n \"0.5440062\",\n \"0.53989565\",\n \"0.5391574\",\n \"0.53773606\",\n \"0.5367243\",\n \"0.5364569\",\n \"0.53270596\",\n \"0.5309413\",\n \"0.5289387\",\n \"0.5285121\",\n \"0.5281236\",\n \"0.5279765\",\n \"0.5275161\",\n \"0.52578974\",\n \"0.52578956\",\n \"0.52507865\",\n \"0.52462655\",\n \"0.524545\",\n \"0.5240002\",\n \"0.5238868\",\n \"0.5228455\",\n \"0.5219578\",\n \"0.5213035\",\n \"0.5201603\",\n \"0.51988834\",\n \"0.519841\",\n \"0.51963055\",\n \"0.51918846\",\n \"0.5188026\",\n \"0.5181621\",\n \"0.51804537\",\n \"0.5174792\",\n \"0.5173135\",\n \"0.5172104\",\n \"0.51489264\",\n \"0.51478297\",\n \"0.514756\",\n \"0.5140056\",\n \"0.513984\",\n \"0.51387894\",\n \"0.51375234\",\n \"0.5135871\",\n \"0.5135654\",\n \"0.51249135\",\n \"0.51189345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6218101"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":4497,"cells":{"query":{"kind":"string","value":"Check that all nonoptional datasets specified in the corresponding manifest strand in the twine are present in the given manifest."},"document":{"kind":"string","value":"def _validate_all_expected_datasets_are_present_in_manifest(self, manifest_kind, manifest):\n # This is the manifest schema included in the `twine.json` file, not the schema for `manifest.json` files.\n manifest_schema = getattr(self, manifest_kind)\n\n for expected_dataset_name, expected_dataset_schema in manifest_schema[\"datasets\"].items():\n if expected_dataset_name in manifest[\"datasets\"]:\n continue\n\n if expected_dataset_schema.get(\"optional\", False):\n continue\n\n raise exceptions.invalid_contents_map[manifest_kind](\n f\"A dataset named {expected_dataset_name!r} is expected in the {manifest_kind} but is missing.\"\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def check_manifest(manifest):\n if not manifest:\n raise Exception('manifest is null')\n\n for key in ['dublin_core', 'checking', 'projects']:\n if key not in manifest:\n raise Exception('manifest missing key \"{0}\"'.format(key))\n\n # check checking\n for key in ['checking_entity', 'checking_level']:\n if key not in manifest['checking']:\n raise Exception('manifest missing checking key \"{0}\"'.format(key))\n\n if not isinstance(manifest['checking']['checking_entity'], list):\n raise Exception('manifest key checking.checking_entity must be an array')\n\n # check projects\n if not isinstance(manifest['projects'], list):\n raise Exception('manifest key projects must be an array')\n\n for key in ['categories', 'identifier', 'path', 'sort', 'title', 'versification']:\n for project in manifest['projects']:\n if key not in project:\n raise Exception('manifest missing project key \"{0}\"'.format(key))\n\n # check dublin_core\n for key in ['conformsto', 'contributor', 'creator', 'description', 'format', 'identifier', 'issued', 'language',\n 'modified', 'publisher', 'relation', 'rights', 'source', 'subject', 'title', 'type', 'version']:\n if key not in manifest['dublin_core']:\n raise Exception('manifest missing dublin_core key \"{0}\"'.format(key))\n\n expectedRCVersion = 'rc0.2'\n if manifest['dublin_core']['conformsto'].lower() != expectedRCVersion:\n raise Exception('unsupported rc version {}. Expected {}'.format(manifest['dublin_core']['conformsto'], expectedRCVersion))\n\n for key in ['direction', 'identifier', 'title']:\n if key not in manifest['dublin_core']['language']:\n raise Exception('manifest missing dublin_core.language key \"{0}\"'.format(key))\n\n if not isinstance(manifest['dublin_core']['source'], list):\n raise Exception('manifest key dublin_core.source must be an array')\n\n for key in ['version', 'identifier', 'language']:\n for source in manifest['dublin_core']['source']:\n if key not in source:\n raise Exception('manifest missing dublin_core.source key \"{0}\"'.format(key))","def _IsApplicable(self, manifest):\n check_list = [(self.tool, manifest.tool), (self.board, manifest.board)]\n\n return all(fnmatch(text, pattern) for text, pattern in check_list)","def _warn_for_missing_datasets(self, datasets: set[str]):\n any_missing = False\n for ds in datasets:\n if not self.frames.has_dataset(ds):\n any_missing = True\n logger.warn(f'dataset \"{ds}\" is not in the database')\n if any_missing:\n logger.warn(f\"datasets in the databse: {self.all_datasets()}\")","def validate_manifest(parser, options):\n if not options.manifest:\n return\n\n template = \"When specifying --manifest, {0} is also required\"\n\n if not options.manifest_id:\n parser.error(template.format(\"--manifest-id\"))\n \n if not options.manifest_service:\n parser.error(template.format(\"--manifest-service\"))\n\n if not options.manifest_version:\n parser.error(template.format(\"--manifest-version\"))","def test_valid_and_empty_manifest(self):\n collector = PypiCollector()\n collector.parse_and_collect(MANIFEST_START + DEP_1, True)\n collector.parse_and_collect(None, True)\n packages = dict(collector.counter.most_common())\n assert packages == {\n 'daiquiri': 1\n }","def validate_manifest(manifest_json):\n manifest_json = copy.deepcopy(manifest_json)\n for field in [\"schemes\", \"host\", \"basePath\", \"info\"]:\n if field not in manifest_json:\n raise exceptions.ValidationError(\n click.style(\"Field '{}' is missing from the manifest file.\", fg=\"red\").format(field),\n json=manifest_json)\n\n for field in [\"contact\", \"title\", \"description\", \"x-21-total-price\", \"x-21-quick-buy\", \"x-21-category\"]:\n if field not in manifest_json[\"info\"]:\n raise exceptions.ValidationError(\n click.style(\n \"Field '{}' is missing from the manifest file under the 'info' section.\",\n fg=\"red\").format(field),\n json=manifest_json)\n\n for field in {\"name\", \"email\"}:\n if field not in manifest_json[\"info\"][\"contact\"]:\n raise exceptions.ValidationError(\n click.style(\n \"Field '{}' is missing from the manifest file under the 'contact' section.\", fg=\"red\")\n .format(field),\n json=manifest_json)\n\n for field in [\"min\", \"max\"]:\n if field not in manifest_json[\"info\"][\"x-21-total-price\"]:\n raise exceptions.ValidationError(\n click.style(\"Field '{}' is missing from the manifest file under the \"\n \"'x-21-total-price' section.\",\n fg=\"red\"),\n json=manifest_json)\n\n if len(manifest_json[\"schemes\"]) == 0:\n raise exceptions.ValidationError(\n click.style(\n \"You have to specify either HTTP or HTTPS for your endpoint under the \"\n \"`schemes` section.\",\n fg=\"red\"),\n json=manifest_json)\n\n valid_app_categories = {'blockchain', 'entertainment', 'social', 'markets', 'utilities', 'iot'}\n if manifest_json[\"info\"][\"x-21-category\"].lower() not in valid_app_categories:\n valid_categories = \", \".join(valid_app_categories)\n raise exceptions.ValidationError(\n click.style(\"'{}' is not a valid category for the 21 marketplace. Valid categories are {}.\",\n fg=\"red\").format(\n manifest_json[\"info\"][\"x-21-category\"], valid_categories),\n json=manifest_json)","def data_available(dataset_name=None):\r\n for file_list in data_resources[dataset_name]['files']:\r\n for file in file_list:\r\n if not os.path.exists(os.path.join(data_path, dataset_name, file)):\r\n return False\r\n return True","def supports_manifest(manifest):\n pass","def test_theme_manifest(err, xpi_package=None):\n\n # Don't even both with the test(s) if there's no chrome.manifest.\n chrome = err.get_resource('chrome.manifest')\n if not chrome:\n return\n\n for triple in chrome.triples:\n subject = triple['subject']\n # Test to make sure that the triple's subject is valid\n if subject not in ('skin', 'style'):\n err.warning(\n err_id=('themes', 'test_theme_manifest',\n 'invalid_chrome_manifest_subject'),\n warning='Invalid chrome.manifest subject',\n description=('chrome.manifest files for full themes are only '\n \"allowed to have 'skin' and 'style' items. \"\n 'Other types of items are disallowed for '\n 'security reasons.',\n 'Invalid subject: %s' % subject),\n filename=triple['filename'],\n line=triple['line'],\n context=triple['context'])","def test_is_valid_manifest_with_missing_size_column(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_missing_size_column.tsv\",\n )\n missing_size_message = (\n 'could not find a column name corresponding to required \"Columns.SIZE\"'\n )\n assert missing_size_message in caplog.text\n assert result == False","def test_is_valid_manifest_with_missing_url_column_and_error_on_empty_url(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_missing_url_column.tsv\",\n error_on_empty_url=True,\n )\n missing_size_message = (\n 'could not find a column name corresponding to required \"Columns.URL\"'\n )\n assert missing_size_message in caplog.text\n assert result == False","def test_is_valid_manifest_format_with_no_errors(caplog):\n assert (\n is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_no_errors.tsv\"\n )\n == True\n )\n assert caplog.text == \"\"","def test_is_valid_manifest_with_missing_url_column(caplog):\n logging.getLogger().setLevel(logging.WARNING)\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_missing_url_column.tsv\",\n )\n missing_size_message = (\n 'could not find a column name corresponding to required \"Columns.URL\"'\n )\n assert missing_size_message in caplog.text\n assert result == True","def test_is_valid_manifest_format_with_many_types_of_errors(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_many_types_of_errors.tsv\",\n )\n error_log = caplog.text\n manifest_with_many_types_of_errors_helper(error_log)\n assert result == False","def test_required_attributes(self):\n\n required_attributes = ('ID', )\n\n for attribute in required_attributes:\n self.assertIn(attribute, dir(DatasetLoader_Jakob2019))","def sanity_check(hdf):\n required_paths = ['Analyses', 'UniqueGlobalKey', 'Analyses/EventDetection_000']\n try:\n for p in required_paths:\n if p not in hdf:\n return False\n return True\n except:\n return False","def readManifestFile(syn, manifestFile):\n table.test_import_pandas()\n import pandas as pd\n\n sys.stdout.write('Validation and upload of: %s\\n' % manifestFile)\n # Read manifest file into pandas dataframe\n df = pd.read_csv(manifestFile, sep='\\t')\n if 'synapseStore' not in df:\n df = df.assign(synapseStore=None)\n df.synapseStore[df['path'].apply(is_url)] = False # override synapseStore values to False when path is a url\n df.synapseStore[df['synapseStore'].isnull()] = True # remaining unset values default to True\n df.synapseStore = df.synapseStore.astype(bool)\n df = df.fillna('')\n\n sys.stdout.write('Validating columns of manifest...')\n for field in REQUIRED_FIELDS:\n sys.stdout.write('.')\n if field not in df.columns:\n sys.stdout.write('\\n')\n raise ValueError(\"Manifest must contain a column of %s\" % field)\n sys.stdout.write('OK\\n')\n\n sys.stdout.write('Validating that all paths exist')\n df.path = df.path.apply(_check_path_and_normalize)\n\n sys.stdout.write('OK\\n')\n\n sys.stdout.write('Validating that all files are unique...')\n if len(df.path) != len(set(df.path)):\n raise ValueError(\"All rows in manifest must contain a unique file to upload\")\n sys.stdout.write('OK\\n')\n\n sys.stdout.write('Validating provenance...')\n df = _sortAndFixProvenance(syn, df)\n sys.stdout.write('OK\\n')\n\n sys.stdout.write('Validating that parents exist and are containers...')\n parents = set(df.parent)\n for synId in parents:\n try:\n container = syn.get(synId, downloadFile=False)\n except SynapseHTTPError:\n sys.stdout.write('\\n%s in the parent column is not a valid Synapse Id\\n' % synId)\n raise\n if not is_container(container):\n sys.stdout.write('\\n%s in the parent column is is not a Folder or Project\\n' % synId)\n raise SynapseHTTPError\n sys.stdout.write('OK\\n')\n return df","def count_missing_stats(manifest):\n num_missing = 0\n for element in manifest:\n if element.missing_stats():\n num_missing += 1\n return num_missing","def is_manifest_list(self):\n return False","def split_manifest(root_path, manifest_file_path):\n\n train_manifest = open(os.path.join(root_path,\"dataset\", \"train_manifest.txt\"), \"w+\")\n test_manifest = open(os.path.join(root_path, \"dataset\",\"test_manifest.txt\"), \"w+\")\n val_manifest = open(os.path.join(root_path,\"dataset\" ,\"valid_manifest.txt\"), \"w+\")\n with open(os.path.join(root_path, manifest_file_path), 'r') as f:\n data_manifest = f.read().strip().split('\\n')\n data_len = len(data_manifest)\n k = 0\n for i in data_manifest:\n if k == 0:\n k = k+1\n continue\n elif k == 1:\n train_manifest.write(i+'\\n')\n test_manifest.write(i+'\\n')\n val_manifest.write(i+'\\n')\n elif k <= data_len*0.6: # 60% on train set\n train_manifest.write(i+'\\n')\n elif k > data_len*0.6 and k <= data_len*0.8: # 20 % on test\n test_manifest.write(i+'\\n')\n else: #20 % on test\n val_manifest.write(i+'\\n')\n k = k+1\n print(\"Spliting attritutes Done!\")","def test_is_valid_manifest_with_missing_md5_column(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_missing_md5_column.tsv\",\n )\n missing_md5_message = (\n 'could not find a column name corresponding to required \"Columns.MD5\"'\n )\n assert missing_md5_message in caplog.text\n assert result == False","def verify_wilds(self):\n self.check_dataset_duplicate_ids(self.wilds)","def test_manifest(self):\n self.parse_manifest()\n\n ids = {}\n errors = []\n collisions = []\n manifest = self.cryptomattes[self.selection][\"names_to_IDs\"]\n for name, idvalue in manifest.iteritems():\n if mm3hash_float(name) != idvalue:\n errors.append(\"computed ID doesn't match manifest ID: (%s, %s)\" % (idvalue, mm3hash_float(name)))\n else:\n if idvalue in ids:\n collisions.append(\"colliding: %s %s\" % (ids[idvalue], name))\n ids[idvalue] = name\n\n print \"Tested %s, %s names\" % (self.nuke_node.name(), len(manifest))\n print \" \", len(errors), \"non-matching IDs between python and c++.\"\n print \" \", len(collisions), \"hash collisions in manifest.\"\n\n return errors, collisions","def test_sa_mismatch_manifest_file_and_ecosystem(self):\n with open(str(Path(__file__).parent.parent.parent) +\n '/data/manifests/202/npmlist.json', 'rb') as fp:\n fs = FileStorage(stream=fp, filename='npmlist.json')\n with pytest.raises(Exception) as exception:\n sa_post_request = StackAnalysesPostRequest(manifest=fs, file_path='/tmp/bin',\n ecosystem='pypi', show_transitive=True)\n sa = StackAnalyses(sa_post_request)\n sa.post_request()\n self.assertIs(exception.type, ValidationError)","def check_dataset(number_episode_dics):\n\n for env_name in number_episode_dics.keys():\n\n check_folder(env_name, number_episode_dics[env_name])","def check_for_data():\n if not (os.path.exists(ep.get_test_data_path()) or os.path.exists(ep.get_dbn_weight_path())):\n return False\n return True","def test_is_valid_manifest_format_with_empty_url(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_empty_url.tsv\",\n )\n assert caplog.text == \"\"\n assert result == True","def check_unstructured(extractions):\n if not extractions:\n return True\n for ext in extractions:\n if not hasattr(ext, 'args'):\n return False\n return True","def cross_validate(self, contents, required=None, forbidden=None):\n if required:\n for item in required:\n self.assertTrue(\n item in contents,\n \"Required entry [{item}] not found in:\\n{contents}\".format(\n item=item, contents=contents\n )\n )\n if forbidden:\n for item in forbidden:\n self.assertTrue(\n item not in contents,\n \"Forbidden entry [{item}] found in:\\n{contents}\".format(\n item=item, contents=contents\n )\n )","def test_invalid_manifest_filepath(self):\n load_manifest(\"./ehiiehaiehnatheita\")","def _check_availability(self, names: Iterable) -> None:\n unavailable = [x for x in names if x not in self.__by_name.keys()]\n if unavailable:\n raise ValueError(f'datasets: {unavailable} not available in the {self.region} region.')","def check_dataset_exists(dataset):\n result = subprocess.call(['das_client.py', '--query', 'dataset dataset=%s' % dataset])\n return result == 0","def _verify(self) -> None:\n # Check if the files already exist\n if os.path.exists(os.path.join(self.root, self.image_root)):\n return\n\n # Check if .zip files already exists (if so extract)\n exists = []\n for filename, md5 in zip(self.filenames, self.md5s):\n filepath = os.path.join(self.root, filename)\n if os.path.isfile(filepath):\n if self.checksum and not check_integrity(filepath, md5):\n raise RuntimeError(\"Dataset found, but corrupted.\")\n exists.append(True)\n extract_archive(filepath)\n else:\n exists.append(False)\n\n if all(exists):\n return\n\n # Check if the user requested to download the dataset\n raise RuntimeError(\n \"Dataset not found in `root` directory, either specify a different\"\n + \" `root` directory or manually download the dataset to this directory.\"\n )","def check_data_struct():\n if not os.path.exists(PROJECT_ROOT+'/data'):\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), PROJECT_ROOT+'/data')\n\n if not os.path.exists(PROJECT_ROOT+'/data/CUB_200_2011'):\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), PROJECT_ROOT+'/data/CUB_200_2011')\n\n if not os.path.exists(PROJECT_ROOT+'/data/segmentations'):\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), PROJECT_ROOT+'/data/segmentations')\n\n if not os.path.exists(PROJECT_ROOT+'/data/attributes.txt'):\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), PROJECT_ROOT+'/data/attributes.txt')","def checkMetadata(self):\n super(WorldfileMultiple, self).checkMetadata()\n \n # Check for necessary information in metadata\n if not 'basin_rast' in self.grassMetadata:\n raise MetadataException(\"Metadata in project directory %s does not contain a basin raster in a GRASS mapset\" % (self.context.projectDir,))\n if not 'subbasins_rast' in self.grassMetadata:\n raise MetadataException(\"Metadata in project directory %s does not contain a sub-basin raster in a GRASS mapset\" % (self.context.projectDir,))\n if not 'dem_rast' in self.grassMetadata:\n raise MetadataException(\"Metadata in project directory %s does not contain a DEM raster in a GRASS mapset\" % (self.context.projectDir,)) \n if not 'soil_rast' in self.grassMetadata:\n raise MetadataException(\"Metadata in project directory %s does not contain a soil raster in a GRASS mapset\" % (self.context.projectDir,))\n if not 'patch_rast' in self.grassMetadata:\n raise MetadataException(\"Metadata in project directory %s does not contain a patch raster in a GRASS mapset\" % (self.context.projectDir,))\n \n if not 'rhessys_dir' in self.metadata:\n raise MetadataException(\"Metadata in project directory %s does not contain a RHESSys directory\" % (self.context.projectDir,))\n if not 'g2w_bin' in self.metadata:\n raise MetadataException(\"Metadata in project directory %s does not contain a grass2world executable\" % (self.context.projectDir,))\n if not 'rat_bin' in self.metadata:\n raise MetadataException(\"Metadata in project directory %s does not contain an AverageTables executable\" % (self.context.projectDir,))\n if not 'template' in self.metadata:\n raise MetadataException(\"Metadata in project directory %s does not contain a world template\" % (self.context.projectDir,))\n if not 'rhessys_dir' in self.metadata:\n raise MetadataException(\"Metadata in project directory {0} does not contain a RHESSys directory\".format(self.context.projectDir))","def testGetManifest(self):\n manifest = self.dl_object._GetManifest()\n self.assertEqual(manifest.get('mediaType'),\n 'application/vnd.docker.distribution.manifest.v2+json')\n self.assertIn('layers', manifest)","def test_existence_checking(self):\n params = [f'2010-{num:0>2}' for num in range(1, 13)] # all month of 2010\n for month in params:\n with self.assertRaises(ValueError) as cm: # ValueError should be raised with proper message\n download_data(month)\n self.assertEqual(f'Dataset from {month} cannot be found on lichess.org', cm.exception.args[0], msg=month)\n # check if error message was as expected","def test_MergeManifests_missing_files():\n d1 = dpack_pb2.DataPackage()\n f1 = d1.file.add()\n f1.relative_path = \"a\"\n f1.comment = \"abc\"\n d2 = dpack_pb2.DataPackage()\n f2 = d2.file.add()\n f2.relative_path = \"b\"\n f2.comment = \"def\"\n dpack.MergeManifests(d1, d2)\n assert d1.file[0].comment == \"abc\"\n assert d2.file[0].comment == \"def\"","def has_required_programs(program_list):\n \n returnValue = True\n \n for program in program_list:\n if commands.getstatusoutput(\"which \"+program)[0] != 0:\n log.error(program+\" is required by \"+PROGRAM_NAME)\n returnValue = False\n \n return returnValue","def dataset_name_matches_in_xif_and_schema(self):\n\n def get_dataset_from_xif(xif_file_path: str) -> List[str]:\n with open(xif_file_path) as xif_file:\n xif_content = xif_file.read()\n dataset = re.findall('dataset[ ]?=[ ]?([\"a-zA-Z_0-9]+)', xif_content)\n if dataset:\n return [dataset_name.strip('\"') for dataset_name in dataset]\n return []\n\n xif_file_path = get_files_in_dir(\n os.path.dirname(self.file_path), [\"xif\"], False\n )\n if xif_file_path and self.schema_content:\n xif_datasets = set(get_dataset_from_xif(xif_file_path[0]))\n schema_datasets = self.schema_content.keys()\n if len(xif_datasets) == len(schema_datasets) and len(xif_datasets) >= 1:\n all_exist = all(dataset in schema_datasets for dataset in xif_datasets)\n if all_exist:\n return True\n\n error_message, error_code = Errors.modeling_rule_schema_xif_dataset_mismatch()\n if self.handle_error(error_message, error_code, file_path=self.file_path):\n self._is_valid = False\n return False","def test_index_manifest_packages_failure(data, gen3_index, gen3_auth, logfile):\n with patch(\n \"gen3.tools.indexing.index_manifest.Gen3Metadata.create\", MagicMock()\n ) as mock_mds_create:\n index_object_manifest(\n manifest_file=f\"{CURRENT_DIR}/test_data/{data['manifest']}\",\n auth=gen3_auth,\n commons_url=gen3_index.client.url,\n thread_num=1,\n replace_urls=False,\n submit_additional_metadata_columns=True,\n )\n mds_records = {\n kwargs[\"guid\"]: kwargs[\"metadata\"]\n for (_, kwargs) in mock_mds_create.call_args_list\n }\n assert len(mds_records) == 0\n\n indexd_records = {r[\"did\"]: r for r in gen3_index.get_all_records()}\n assert len(indexd_records) == 0\n\n for error in data[\"expected_error_msgs\"]:\n assert error in logfile.read()","def exists_dataset(self, dataset):\n assert dataset, \"Must input a valid dataset name.\"\n return any(self.get_by_dataset(dataset))","def check_dataset_presence(dataset, verbose=False):\n quantities = ['name', 'dataset_fraction', 'replica_fraction', 'block_fraction', 'block_completion']\n\n # Get site name and fractions for each site\n # yes, you prob shouldn't use shell=True, but CBA to figure out how to split the string for das_client\n grep_str = ' '.join(['site.%s' % q for q in quantities])\n out = check_output('das_client --query=\"site dataset=%s | grep %s\"' % (dataset, grep_str), shell=True)\n\n site_dicts = [] # hold info about each site\n\n # Process the important lines, store in a dict for each site\n results = [x for x in out.split('\\n') if 'Showing' not in x and x != '']\n for line in results:\n # Don't care if it's at a T1\n if line.startswith('T1'):\n continue\n sdict = {q : p for q, p in zip(quantities, line.split())}\n site_dicts.append(sdict)\n\n if verbose:\n # Print output for each site with fractions, colour coded\n print TColour.BLUE, dataset, TColour.ENDC\n print '\\t %s' % ' - '.join(quantities)\n for sdict in site_dicts:\n fracs = [sdict[k] for k in quantities]\n status_col = TColour.RED\n if all([f == '100.00%' for f in fracs if not f.startswith('T')]):\n status_col = TColour.GREEN\n print '\\t', status_col, ' - '.join(fracs), TColour.ENDC\n else:\n # Figure out if fully transferred anywhere, in which case print in green\n transferred = False\n for sdict in site_dicts:\n fracs = [sdict[k] for k in quantities]\n if all([f == '100.00%' for f in fracs if not f.startswith('T')]):\n transferred = True\n break\n\n status_col = TColour.GREEN if transferred else TColour.RED\n status_letter = 'v' if transferred else 'x'\n print status_col, status_letter, dataset, TColour.ENDC","def test_is_valid_manifest_format_using_error_on_empty_url(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_empty_url.tsv\",\n error_on_empty_url=True,\n )\n assert '\"\"' in caplog.text\n assert result == False","def test_no_updated_datasets(self):\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n for dataset in self.datasets_v3:\n self.assertNotIn(dataset, table.data)","def test_is_valid_manifest_format_with_invalid_authz_resources(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_invalid_authz_resources.tsv\",\n )\n error_log = caplog.text\n assert '\"invalid_authz\"' in error_log\n assert '\"/\"' in error_log\n assert '\"//\"' in error_log\n assert '\"///\"' in error_log\n assert '\"invalid_authz2\"' in error_log\n assert result == False","def requirement_missing(script):\n if \"requires\" in script:\n if script[\"requires\"] is None:\n return False\n for package in script[\"requires\"].split():\n try:\n pkg_resources.working_set.require(package)\n except Exception:\n return True\n return False","def check_structured(extractions):\n if not extractions:\n return True\n for ext in extractions:\n if not hasattr(ext, 'arg1'):\n return False\n return True","def is_empty(self):\n for key, dataset in self.datasets.items():\n try:\n has_data = dataset.has_data()\n except MFDataException as mfde:\n raise MFDataException(\n mfdata_except=mfde,\n model=self._container_package.model_name,\n package=self._container_package._get_pname(),\n message=\"Error occurred while verifying\"\n ' data of dataset \"{}\" in block '\n '\"{}\"'.format(dataset.structure.name, self.structure.name),\n )\n\n if has_data is not None and has_data:\n return False\n return True","def test_with_valid_input(self):\n for dataset_type in ['regular', 'raw', 'REGULAR', 'RAW']:\n try:\n check_dataset_type(dataset_type)\n except ValueError:\n self.fail(\"Dataset {0} should be valid\".format(dataset_type))","def test_is_valid_manifest_with_wide_row(caplog):\n logging.getLogger().setLevel(logging.WARNING)\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_wide_row.tsv\",\n )\n wide_warning = f\"line 3, number of fields (6) in row is unequal to number of column names in manifest (5)\"\n assert wide_warning in caplog.text\n assert result == True","def _validate_manifest(self, kind, source, cls=None, **kwargs):\n data = self._load_json(kind, source, **kwargs)\n\n # TODO elegant way of cleaning up this nasty serialisation hack to manage conversion of outbound manifests to primitive\n inbound = True\n if hasattr(data, \"to_primitive\"):\n inbound = False\n data = data.to_primitive()\n\n self._validate_against_schema(kind, data)\n self._validate_all_expected_datasets_are_present_in_manifest(manifest_kind=kind, manifest=data)\n\n if cls and inbound:\n return cls(**data)\n\n return data","def test_metadata_atleast_latin_menu_subsets_exist(self):\n self.assertIn('menu', self.metadata.get('subsets', []),\n msg=\"Subsets missing menu\")\n self.assertIn('latin', self.metadata.get('subsets', []),\n msg=\"Subsets missing latin\")","def validate_manifest(\n request: ValidateManifestRequest = Body(...),\n schema: Any = Depends(get_description_schema),\n) -> ValidateManifestResponse:\n\n _, response = _validate_manifest(request, schema)\n return response","def checkIfThereIsData(self, i):\n _, amountOfThings = self.weaviate.Get(\"/\" + i)\n if len(amountOfThings[i]) == 0:\n return False\n else:\n return True","def _check_manifest_resources(self, documents: list) -> str:\n for doc in documents:\n kind = doc.get(\"kind\")\n\n # If this kind defines a job template, pull it out\n if kind in JOB_TEMPLATE_RESOURCES:\n doc = doc.get(\"spec\").get(\"jobTemplate\")\n if doc is None:\n return f\"{kind} resources MUST specify a job template!\"\n\n if kind in POD_TEMPLATE_RESOURCES:\n pod_template = doc.get(\"spec\").get(\"template\")\n if pod_template is None:\n return f\"{kind} resources MUST specify a pod template!\"\n\n pod_spec = pod_template.get(\"spec\")\n if pod_spec is None:\n return f\"{kind} resources MUST specify a pod spec!\"\n\n containers = pod_spec.get(\"containers\")\n if not containers:\n return f\"{kind} resources MUST specify at least one container!\"\n\n init_containers = pod_spec.get(\"initContainers\")\n if init_containers:\n containers = containers + init_containers\n\n missing_resources_msg = (\n f\"All containers and initContainers in a {kind}\"\n \"must define resource constraints!\"\n )\n for cont in containers:\n resources = cont.get(\"resources\")\n if not resources:\n return missing_resources_msg\n\n limits = resources.get(\"limits\")\n if not limits or not limits.get(\"cpu\") or not limits.get(\"memory\"):\n return missing_resources_msg\n\n requests = resources.get(\"requests\")\n if (\n not requests\n or not requests.get(\"cpu\")\n or not requests.get(\"memory\")\n ):\n return missing_resources_msg","def test_check_metadata_fields(self):\n contents = self.read_metadata_contents()\n family = Metadata.get_family_metadata(contents)\n\n keys = [(\"name\", str), (\"postScriptName\", str),\n (\"fullName\", str), (\"style\", str),\n (\"weight\", int), (\"filename\", str),\n (\"copyright\", str)]\n\n missing = set([])\n unknown = set([])\n\n for j, itemtype in keys:\n\n for font_metadata in family.fonts:\n if j not in font_metadata:\n missing.add(j)\n\n for k in font_metadata:\n if k not in map(lambda x: x[0], keys):\n unknown.add(k)\n\n if unknown:\n msg = 'METADATA.json \"fonts\" property has unknown items [%s]'\n self.fail(msg % ', '.join(unknown))\n\n if missing:\n msg = 'METADATA.json \"fonts\" property items missed [%s] items'\n self.fail(msg % ', '.join(missing))","def check_dataset_files_outside_datadir(fix, dataset_gateway: IDatasetGateway, **_):\n invalid_files = []\n for dataset in dataset_gateway.get_provenance_tails():\n if dataset.date_removed:\n continue\n\n data_dir = dataset.get_datadir()\n\n detected_files = []\n\n for file in dataset.files:\n if file.is_external or file.linked:\n continue\n try:\n get_safe_relative_path(project_context.path / file.entity.path, project_context.path / data_dir)\n except ValueError:\n detected_files.append(file)\n\n if not detected_files:\n continue\n\n if fix:\n communication.info(f\"Fixing dataset '{dataset.name}' files.\")\n dataset.unfreeze()\n for file in detected_files:\n dataset.unlink_file(file.entity.path)\n dataset.freeze()\n add_to_dataset(dataset.name, urls=[file.entity.path for file in detected_files], link=True)\n else:\n invalid_files.extend(detected_files)\n\n if invalid_files:\n problems = (\n WARNING\n + \"There are dataset files that aren't inside their dataset's data directory \"\n + \"(use 'renku doctor --fix' to fix them):\\n\\n\\t\"\n + \"\\n\\t\".join(click.style(file.entity.path, fg=\"yellow\") for file in invalid_files)\n + \"\\n\"\n )\n return False, True, problems\n\n return True, False, None","def is_manifest(location):\n return as_posixpath(location).lower().endswith('meta-inf/manifest.mf')","def _dist_has_meta_data(dist: pkg_resources.Distribution) -> bool:\n return dist.has_metadata('direct_url.json')","def test_compatible_data_presence(allparams):\n compatible_data_keys_set = set(['puf', 'cps'])\n\n # Nested function used only in test_compatible_data_presence\n def valid_compatible_data(compatible_data):\n \"\"\"\n Return True if compatible_data is a valid dictionary;\n otherwise return False\n \"\"\"\n if not isinstance(compatible_data, dict):\n return False\n if set(compatible_data.keys()) != compatible_data_keys_set:\n return False\n for key in compatible_data:\n boolean = (compatible_data[key] is True or\n compatible_data[key] is False)\n if not boolean:\n return False\n return True\n\n # Main logic of test_compatible_data_presence function\n problem_pnames = list()\n for pname in allparams:\n if 'compatible_data' in allparams[pname]:\n compatible_data = allparams[pname]['compatible_data']\n else:\n compatible_data = None\n if not valid_compatible_data(compatible_data):\n problem_pnames.append(pname)\n if problem_pnames:\n msg = '{} has no or invalid compatible_data field'\n for pname in problem_pnames:\n print(msg.format(pname))\n assert 'list of problem_pnames' == 'empty list'","def check_expected_present(self, data, expected, premessage):\n # check missing\n missing = list(d for d in expected if d not in data)\n if missing:\n self.raiseAWarning(premessage, '| Expected variables are missing:', missing)\n # check None\n nones = list(d for d, v in data.items() if (v is None and v in expected))\n if nones:\n self.raiseAWarning(premessage, '| Expected variables are None:', nones)\n if missing or nones:\n self.raiseAnError(RuntimeError, 'Some variables were missing or None! See warning messages above for details!')","def exists():\n check50.include(\"data\")\n check50.exists(\"adventure.py\")\n check50.exists(\"room.py\")","def test_incorrect_dependency(self):\n load_manifest(StringIO(manifest_incorrect_dependency))","def has_extras(self):\n return any(map(utils.assert_package_has_extras, self.pkg_arguments))","def _verify(self) -> None:\n # Check if the extracted files already exist\n pathname = os.path.join(self.root, self.data_dir)\n if os.path.exists(pathname):\n return\n\n # Check if the zip files have already been downloaded\n pathname = os.path.join(self.root, self.data_dir) + \".zip\"\n if os.path.exists(pathname):\n self._extract()\n return\n\n # Check if the user requested to download the dataset\n if not self.download:\n raise RuntimeError(\n f\"Dataset not found in `root={self.root}` and `download=False`, \"\n \"either specify a different `root` directory or use `download=True` \"\n \"to automatically download the dataset.\"\n )\n\n # Download the dataset\n self._download()\n self._extract()","def check_data():\n check_docs(\"Training\")\n check_docs(\"dev\")\n check_docs(\"Test\")","def validate_dataset(self):\n pass","def test_sanity(self):\n\n parser = ManifestParser()\n mozmill_example = os.path.join(here, 'mozmill-example.ini')\n parser.read(mozmill_example)\n tests = parser.tests\n self.assertEqual(len(tests), len(file(mozmill_example).read().strip().splitlines()))\n\n # Ensure that capitalization and order aren't an issue:\n lines = ['[%s]' % test['name'] for test in tests]\n self.assertEqual(lines, file(mozmill_example).read().strip().splitlines())\n\n # Show how you select subsets of tests:\n mozmill_restart_example = os.path.join(here, 'mozmill-restart-example.ini')\n parser.read(mozmill_restart_example)\n restart_tests = parser.get(type='restart')\n self.assertTrue(len(restart_tests) < len(parser.tests))\n self.assertEqual(len(restart_tests), len(parser.get(manifest=mozmill_restart_example)))\n self.assertFalse([test for test in restart_tests\n if test['manifest'] != os.path.join(here, 'mozmill-restart-example.ini')])\n self.assertEqual(parser.get('name', tags=['foo']),\n ['restartTests/testExtensionInstallUninstall/test2.js',\n 'restartTests/testExtensionInstallUninstall/test1.js'])\n self.assertEqual(parser.get('name', foo='bar'),\n ['restartTests/testExtensionInstallUninstall/test2.js'])","def _validate_data(self):\n logger.debug(\"Validating directory\")\n root = self.data_dir\n for path in self._walk_cases():\n print(path)\n full_path = os.path.join(root, path)\n logger.debug(\" \" + full_path)\n try:\n assert os.path.exists(full_path)\n except AssertionError:\n raise AssertionError(\n \"Couldn't find data on path {}\".format(full_path)\n )","def _validate_num_profiles(self):\n for fp in [self.solar_fpath, self.wind_fpath]:\n with Resource(fp) as res:\n profile_dset_names = [\n n for n in res.dsets\n if self.__profile_reg_check.match(n)\n ]\n if not profile_dset_names:\n msg = (\"Did not find any data sets matching the regex: \"\n \"{!r} in {!r}. Please ensure that the profile data \"\n \"exists and that the data set is named correctly.\")\n e = msg.format(PROFILE_DSET_REGEX, fp)\n logger.error(e)\n raise FileInputError(e)\n elif len(profile_dset_names) > 1:\n msg = (\"Found more than one profile in {!r}: {}. \"\n \"This module is not intended for hybridization of \"\n \"multiple representative profiles. Please re-run \"\n \"on a single aggregated profile.\")\n e = msg.format(fp, profile_dset_names)\n logger.error(e)\n raise FileInputError(e)\n else:\n self.profile_dset_names += profile_dset_names","def _detect_files(data):\n return any(attr[\"extra\"].get(\"files\")\n for attr in data[\"attributes\"] if attr[\"extra\"])","def validate_input_manifest(self, source, **kwargs):\n return self._validate_manifest(\"input_manifest\", source, **kwargs)","def validate_available(parser, options):\n if not options.available:\n return\n\n if not options.manifest_id:\n parser.error(\"When specifying --available, --manifest-id is also required\")","def test_talbot_manifest_fetch():\n request, response = app.test_client.get(\"/iiif/manifest/452d6b51-949c-447d-9880-1108ffdfd96e.json\")\n assert response.status == 200","def test_check_presence_only(self):\n schema = yaml.load(self.yaml_presence_check, Loader=yaml.FullLoader)\n val = DwcaValidator(schema, allow_unknown=True,\n error_handler=WhipErrorHandler)\n\n document = {'abundance': 'many'}\n self.assertTrue(val.validate(document))\n document = {'abundance': ''}\n self.assertTrue(val.validate(document))\n document = {'eventDate': ''}\n val.validate(document)\n self.assertEqual(val.errors, {})","def check_ekin_dataset(cls, ekindatasets):\n for k in ekindatasets.keys():\n ekindataset = ekindatasets[k]\n xdatapoints=ekindataset[0].keys()\n count=0\n for datapoint in xdatapoints:\n if datapoint=='label' or datapoint=='label_widget':\n continue\n else:\n if not isinstance(ekindataset[0][datapoint], dict):\n if ekindataset[0][datapoint] != '':\n return 1\n elif ekindataset[0][datapoint].has_key('var'):\n if ekindataset[0][datapoint]['var']!='':\n return 1\n return 0","def check_missing_files(dataset_gateway: IDatasetGateway, **_):\n missing = defaultdict(list)\n\n for dataset in dataset_gateway.get_all_active_datasets():\n # NOTE: Datasets with storage backend don't have local copies of files\n if dataset.storage:\n continue\n for file_ in dataset.files:\n path = project_context.path / file_.entity.path\n file_exists = path.exists() or (file_.is_external and os.path.lexists(path))\n if not file_exists:\n missing[dataset.name].append(file_.entity.path)\n\n if not missing:\n return True, False, None\n\n problems = WARNING + \"There are missing files in datasets.\"\n\n for dataset_name, files in missing.items():\n problems += (\n \"\\n\\t\"\n + click.style(dataset_name, fg=\"yellow\")\n + \":\\n\\t \"\n + \"\\n\\t \".join(click.style(path, fg=\"red\") for path in files)\n )\n\n return False, False, problems","def test_is_valid_manifest_format_with_invalid_md5_values(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_invalid_md5_values.tsv\"\n )\n\n error_log = caplog.text\n manifest_with_invalid_md5_values_helper(error_log)\n base64_encoded_md5 = '\"jd2L5LF5pSmvpfL/rkuYWA==\"'\n assert base64_encoded_md5 in error_log\n assert result == False","def _check_variables(datasets, necessary_short_names):\n dataset_name = datasets[0]['dataset']\n necessary_short_names = set(necessary_short_names)\n short_names = set(group_metadata(datasets, 'short_name').keys())\n if short_names != necessary_short_names:\n raise ValueError(\n f\"Expected variables {necessary_short_names} for dataset \"\n f\"'{dataset_name}', got {short_names}\")","def check_existing_dataset(path: str):\n x_path = os.path.join(path, IMG_DIR)\n y_path = os.path.join(path, MSK_DIR)\n\n if os.path.isdir(x_path) and os.path.isdir(y_path):\n _, _, x_files = next(os.walk(x_path))\n _, _, y_files = next(os.walk(y_path))\n x = len(x_files)\n y = len(y_files)\n\n if x != y:\n logger.warning(\n \"Found un-even numbers of x-y for dataset. x = %i, y = %i.\", x, y\n )\n\n return -1\n\n if x == 0:\n logger.info(\"Found 0 existing sets.\")\n\n return 0\n logger.info(\"Found %s sets in existing dataset.\", x)\n\n return x\n logger.error(\"Could not locate x and y folder.\")\n sys.exit()","def test_is_valid_manifest_format_with_invalid_sizes(caplog):\n result = is_valid_manifest_format(\n \"tests/validate_manifest_format/manifests/manifest_with_invalid_sizes.tsv\"\n )\n error_log = caplog.text\n assert \"-1\" in error_log\n assert \"not_an_int\" in error_log\n assert \"3.34\" in error_log\n assert \"string_with_42\" in error_log\n assert result == False","def test_exist_entry_on_rebuild(self):\n self.validate_attributes_in_exist_response()","def is_dataset(X, require_attrs=None):\n\n if require_attrs is None:\n require_attrs = [\"data_vars\", \"coords\", \"dims\", \"to_array\"]\n\n return all([hasattr(X, name) for name in require_attrs])","def _check_dataset_consistency(self):\n if not self.multi_dataset: \n raise MutantError(\"_check_dataset_consistency only makes sense for multi-datasets!\")\n def _check_sets_raise_error(set1, set2, set1_name, set2_name):\n if not set1==set2:\n raise MutantError(\"Multi-dataset mutant pool has different %s and %s dataset sets! %s, %s\"%(set1_name, \n set2_name, set1, set2))\n datasets_from_summary = set(self.summary.keys())\n datasets_from_mutants = set.union(*[set(m.by_dataset.keys()) for m in self])\n _check_sets_raise_error(datasets_from_summary, datasets_from_mutants, \"from summary\", \"from mutants\")\n try:\n if self._dataset_order is not None: \n datasets_from_order = set(self._dataset_order)\n _check_sets_raise_error(datasets_from_order, datasets_from_summary, \"from dataset_order\", \"from summary\")\n except AttributeError:\n pass","def check_image_manifest(self,\n idf,\n cids,\n cols = ['md5sum',\n 'storage_urls',\n 'file_size',\n 'case_ids',\n 'study_uid',\n 'series_uid',\n 'file_name']):\n errors = []\n for col in cols:\n missing = len(idf[idf[col].isnull()])\n if missing > 0:\n error = \"'{}' values issing for image manifest column '{}'.\".format(len(missing),col)\n print(error)\n errors.append(error)\n if \"case_ids\" in idf:\n icids = list(set(idf[\"case_ids\"]))\n extra_cids = list(set(icids).difference(cids))\n if len(extra_cids) > 0:\n error = \"The image manifest TSV contains {} case IDs that are not present in the case TSV!\".format(len(extra_cids))\n print(error)\n errors.append(error)\n else:\n error = \"'case_ids' column missing from image manifest!\"\n print(error)\n errors.append(error)\n return errors","def _check_integrity(self):\n root = self.root\n for scene_name in self.scene_list:\n if not(os.path.isdir(os.path.join(root,scene_name)) and \n os.path.isdir(os.path.join(root,scene_name, images_dir)) and\n os.path.isfile(os.path.join(root,scene_name,annotation_filename))):\n return False\n return True","def _check_integrity(self):\n root = self.root\n for scene_name in self.scene_list:\n if not(os.path.isdir(os.path.join(root,scene_name)) and \n os.path.isdir(os.path.join(root,scene_name, images_dir)) and\n os.path.isfile(os.path.join(root,scene_name,annotation_filename))):\n return False\n return True","def check_invalid_datasets_derivation(fix, dataset_gateway: IDatasetGateway, **_):\n invalid_datasets = []\n\n def fix_or_report(dataset):\n if fix:\n dataset.unfreeze()\n dataset.derived_from = None\n dataset.freeze()\n communication.info(f\"Fixing dataset '{dataset.name}'\")\n else:\n invalid_datasets.append(dataset.name)\n\n for dataset in dataset_gateway.get_provenance_tails():\n while dataset.derived_from is not None and dataset.derived_from.url_id is not None:\n if dataset.same_as or dataset.derived_from.url_id == dataset.id:\n fix_or_report(dataset)\n break\n\n try:\n dataset = dataset_gateway.get_by_id(dataset.derived_from.url_id)\n except errors.ObjectNotFoundError:\n fix_or_report(dataset)\n break\n\n if not invalid_datasets:\n return True, False, None\n\n problems = (\n WARNING\n + \"There are invalid dataset metadata in the project (use 'renku doctor --fix' to fix them):\"\n + \"\\n\\n\\t\"\n + \"\\n\\t\".join(click.style(name, fg=\"yellow\") for name in invalid_datasets)\n + \"\\n\"\n )\n\n return False, True, problems","def _check_data_valid(self):\n\n is_valid = (sum(~np.isnan(self.data).flatten()) > 0 and self.data.flatten().sum() != 0)\n if not is_valid:\n raise FITSException(f\"No data in {self.survey}\")","def check(self):\n missing = []\n for name in self.data[\"locations\"]:\n try:\n n = self.data[\"names\"][name]\n except KeyError:\n missing.append(name)\n if missing:\n raise RuntimeError(\"\\\"names\\\" list lacks:\\n \" + \"\\n \".join(missing))","def needs_dataset(*names, default=None):\n non_ion_datasets = ['abundance', 'ip', 'ioneq']\n names = [f'_{n}' if n not in non_ion_datasets else f'{n}' for n in names]\n\n def decorator(func):\n @wraps(func)\n def func_wrapper(*args, **kwargs):\n if any([args[0].__getattribute__(n) is None for n in names]):\n return default\n else:\n return func(*args, **kwargs)\n return func_wrapper\n return decorator","def test_no_removed_datasets(self):\n removed_dataset_1 = factories.SourceDatasetFactory.create(source_study_version=self.study_version_1)\n removed_dataset_2 = factories.SourceDatasetFactory.create(\n source_study_version=self.study_version_2, i_accession=removed_dataset_1.i_accession)\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n self.assertNotIn(removed_dataset_1, table.data)\n self.assertNotIn(removed_dataset_2, table.data)\n self.assertEqual(len(table.data), 0)","def isFilePresent(fileName):\n global dataFolder,blackListFiles\n allDataFiles = [f for f in listdir(dataFolder) if (isfile(join(dataFolder, f)) and f.endswith('.zip'))]\n return fileName in allDataFiles and not (fileName in blackListFiles)","def _CheckFileExistsWithData(self, logs, graph):\n self.assertTrue(graph in logs, 'File %s was not output.' % graph)\n self.assertTrue(logs[graph], 'File %s did not contain data.' % graph)","def test_get_manifest(self):\n expected_start, expected_end = self.mock_data.month_range.split(\"-\")\n\n manifest, _ = self.downloader._get_manifest(self.mock_data.test_date)\n\n self.assertEqual(manifest.get(\"assemblyId\"), self.mock_data.export_uuid)\n self.assertEqual(manifest.get(\"reportKeys\"), [self.mock_data.export_file])\n self.assertEqual(manifest.get(\"Compression\"), \"PLAIN\")\n self.assertEqual(manifest.get(\"billingPeriod\").get(\"start\"), expected_start)\n self.assertEqual(manifest.get(\"billingPeriod\").get(\"end\"), expected_end)","def verify_entry(b):\n for f in minimalfields:\n if f not in b:\n return False\n return True","def check_integrity(self) -> None:\n for subset in self.subsets:\n if not self._check_subset_integrity(subset):\n raise ValueError(f\"subset {subset} not found or corrupt\")","def check_missing_files(self):\n files = [getattr(self, attr) for attr in self._required]\n try:\n utilities.check_missing_files(files)\n except utilities.MissingConstraintError as err:\n err.message += \"\\nSkipping {}\\n\".format(self.__class__.__name__)\n raise err","def get_manifest_data(bucket,team, dataset,manifest_key):\n dynamo_config = DynamoConfiguration()\n dynamo_interface = DynamoInterface(dynamo_config)\n s3_interface = S3Interface()\n local_path = s3_interface.download_object(bucket, manifest_key)\n ddb_keys=[]\n items=[]\n with open(local_path, \"r\") as raw_file:\n file_names = [file_name.strip().split(\"/\")[-1]\n for file_name in raw_file]\n for file in file_names:\n ddb_keys.append({\n \"dataset_name\": team+\"-\"+dataset,\n \"manifest_file_name\": manifest_key.split(\"/\")[-1], \"datafile_name\": file\n })\n for ddb_key in ddb_keys:\n try:\n items.append(dynamo_interface.get_item_from_manifests_control_table(\n ddb_key[\"dataset_name\"], ddb_key[\"manifest_file_name\"], ddb_key[\"datafile_name\"]))\n except KeyError:\n logger.error(\"The manifest file has not been processed in Stage A\")\n raise Exception(\"Manifest File has not been processed in Stage A\")\n\n return items"],"string":"[\n \"def check_manifest(manifest):\\n if not manifest:\\n raise Exception('manifest is null')\\n\\n for key in ['dublin_core', 'checking', 'projects']:\\n if key not in manifest:\\n raise Exception('manifest missing key \\\"{0}\\\"'.format(key))\\n\\n # check checking\\n for key in ['checking_entity', 'checking_level']:\\n if key not in manifest['checking']:\\n raise Exception('manifest missing checking key \\\"{0}\\\"'.format(key))\\n\\n if not isinstance(manifest['checking']['checking_entity'], list):\\n raise Exception('manifest key checking.checking_entity must be an array')\\n\\n # check projects\\n if not isinstance(manifest['projects'], list):\\n raise Exception('manifest key projects must be an array')\\n\\n for key in ['categories', 'identifier', 'path', 'sort', 'title', 'versification']:\\n for project in manifest['projects']:\\n if key not in project:\\n raise Exception('manifest missing project key \\\"{0}\\\"'.format(key))\\n\\n # check dublin_core\\n for key in ['conformsto', 'contributor', 'creator', 'description', 'format', 'identifier', 'issued', 'language',\\n 'modified', 'publisher', 'relation', 'rights', 'source', 'subject', 'title', 'type', 'version']:\\n if key not in manifest['dublin_core']:\\n raise Exception('manifest missing dublin_core key \\\"{0}\\\"'.format(key))\\n\\n expectedRCVersion = 'rc0.2'\\n if manifest['dublin_core']['conformsto'].lower() != expectedRCVersion:\\n raise Exception('unsupported rc version {}. Expected {}'.format(manifest['dublin_core']['conformsto'], expectedRCVersion))\\n\\n for key in ['direction', 'identifier', 'title']:\\n if key not in manifest['dublin_core']['language']:\\n raise Exception('manifest missing dublin_core.language key \\\"{0}\\\"'.format(key))\\n\\n if not isinstance(manifest['dublin_core']['source'], list):\\n raise Exception('manifest key dublin_core.source must be an array')\\n\\n for key in ['version', 'identifier', 'language']:\\n for source in manifest['dublin_core']['source']:\\n if key not in source:\\n raise Exception('manifest missing dublin_core.source key \\\"{0}\\\"'.format(key))\",\n \"def _IsApplicable(self, manifest):\\n check_list = [(self.tool, manifest.tool), (self.board, manifest.board)]\\n\\n return all(fnmatch(text, pattern) for text, pattern in check_list)\",\n \"def _warn_for_missing_datasets(self, datasets: set[str]):\\n any_missing = False\\n for ds in datasets:\\n if not self.frames.has_dataset(ds):\\n any_missing = True\\n logger.warn(f'dataset \\\"{ds}\\\" is not in the database')\\n if any_missing:\\n logger.warn(f\\\"datasets in the databse: {self.all_datasets()}\\\")\",\n \"def validate_manifest(parser, options):\\n if not options.manifest:\\n return\\n\\n template = \\\"When specifying --manifest, {0} is also required\\\"\\n\\n if not options.manifest_id:\\n parser.error(template.format(\\\"--manifest-id\\\"))\\n \\n if not options.manifest_service:\\n parser.error(template.format(\\\"--manifest-service\\\"))\\n\\n if not options.manifest_version:\\n parser.error(template.format(\\\"--manifest-version\\\"))\",\n \"def test_valid_and_empty_manifest(self):\\n collector = PypiCollector()\\n collector.parse_and_collect(MANIFEST_START + DEP_1, True)\\n collector.parse_and_collect(None, True)\\n packages = dict(collector.counter.most_common())\\n assert packages == {\\n 'daiquiri': 1\\n }\",\n \"def validate_manifest(manifest_json):\\n manifest_json = copy.deepcopy(manifest_json)\\n for field in [\\\"schemes\\\", \\\"host\\\", \\\"basePath\\\", \\\"info\\\"]:\\n if field not in manifest_json:\\n raise exceptions.ValidationError(\\n click.style(\\\"Field '{}' is missing from the manifest file.\\\", fg=\\\"red\\\").format(field),\\n json=manifest_json)\\n\\n for field in [\\\"contact\\\", \\\"title\\\", \\\"description\\\", \\\"x-21-total-price\\\", \\\"x-21-quick-buy\\\", \\\"x-21-category\\\"]:\\n if field not in manifest_json[\\\"info\\\"]:\\n raise exceptions.ValidationError(\\n click.style(\\n \\\"Field '{}' is missing from the manifest file under the 'info' section.\\\",\\n fg=\\\"red\\\").format(field),\\n json=manifest_json)\\n\\n for field in {\\\"name\\\", \\\"email\\\"}:\\n if field not in manifest_json[\\\"info\\\"][\\\"contact\\\"]:\\n raise exceptions.ValidationError(\\n click.style(\\n \\\"Field '{}' is missing from the manifest file under the 'contact' section.\\\", fg=\\\"red\\\")\\n .format(field),\\n json=manifest_json)\\n\\n for field in [\\\"min\\\", \\\"max\\\"]:\\n if field not in manifest_json[\\\"info\\\"][\\\"x-21-total-price\\\"]:\\n raise exceptions.ValidationError(\\n click.style(\\\"Field '{}' is missing from the manifest file under the \\\"\\n \\\"'x-21-total-price' section.\\\",\\n fg=\\\"red\\\"),\\n json=manifest_json)\\n\\n if len(manifest_json[\\\"schemes\\\"]) == 0:\\n raise exceptions.ValidationError(\\n click.style(\\n \\\"You have to specify either HTTP or HTTPS for your endpoint under the \\\"\\n \\\"`schemes` section.\\\",\\n fg=\\\"red\\\"),\\n json=manifest_json)\\n\\n valid_app_categories = {'blockchain', 'entertainment', 'social', 'markets', 'utilities', 'iot'}\\n if manifest_json[\\\"info\\\"][\\\"x-21-category\\\"].lower() not in valid_app_categories:\\n valid_categories = \\\", \\\".join(valid_app_categories)\\n raise exceptions.ValidationError(\\n click.style(\\\"'{}' is not a valid category for the 21 marketplace. Valid categories are {}.\\\",\\n fg=\\\"red\\\").format(\\n manifest_json[\\\"info\\\"][\\\"x-21-category\\\"], valid_categories),\\n json=manifest_json)\",\n \"def data_available(dataset_name=None):\\r\\n for file_list in data_resources[dataset_name]['files']:\\r\\n for file in file_list:\\r\\n if not os.path.exists(os.path.join(data_path, dataset_name, file)):\\r\\n return False\\r\\n return True\",\n \"def supports_manifest(manifest):\\n pass\",\n \"def test_theme_manifest(err, xpi_package=None):\\n\\n # Don't even both with the test(s) if there's no chrome.manifest.\\n chrome = err.get_resource('chrome.manifest')\\n if not chrome:\\n return\\n\\n for triple in chrome.triples:\\n subject = triple['subject']\\n # Test to make sure that the triple's subject is valid\\n if subject not in ('skin', 'style'):\\n err.warning(\\n err_id=('themes', 'test_theme_manifest',\\n 'invalid_chrome_manifest_subject'),\\n warning='Invalid chrome.manifest subject',\\n description=('chrome.manifest files for full themes are only '\\n \\\"allowed to have 'skin' and 'style' items. \\\"\\n 'Other types of items are disallowed for '\\n 'security reasons.',\\n 'Invalid subject: %s' % subject),\\n filename=triple['filename'],\\n line=triple['line'],\\n context=triple['context'])\",\n \"def test_is_valid_manifest_with_missing_size_column(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_missing_size_column.tsv\\\",\\n )\\n missing_size_message = (\\n 'could not find a column name corresponding to required \\\"Columns.SIZE\\\"'\\n )\\n assert missing_size_message in caplog.text\\n assert result == False\",\n \"def test_is_valid_manifest_with_missing_url_column_and_error_on_empty_url(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_missing_url_column.tsv\\\",\\n error_on_empty_url=True,\\n )\\n missing_size_message = (\\n 'could not find a column name corresponding to required \\\"Columns.URL\\\"'\\n )\\n assert missing_size_message in caplog.text\\n assert result == False\",\n \"def test_is_valid_manifest_format_with_no_errors(caplog):\\n assert (\\n is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_no_errors.tsv\\\"\\n )\\n == True\\n )\\n assert caplog.text == \\\"\\\"\",\n \"def test_is_valid_manifest_with_missing_url_column(caplog):\\n logging.getLogger().setLevel(logging.WARNING)\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_missing_url_column.tsv\\\",\\n )\\n missing_size_message = (\\n 'could not find a column name corresponding to required \\\"Columns.URL\\\"'\\n )\\n assert missing_size_message in caplog.text\\n assert result == True\",\n \"def test_is_valid_manifest_format_with_many_types_of_errors(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_many_types_of_errors.tsv\\\",\\n )\\n error_log = caplog.text\\n manifest_with_many_types_of_errors_helper(error_log)\\n assert result == False\",\n \"def test_required_attributes(self):\\n\\n required_attributes = ('ID', )\\n\\n for attribute in required_attributes:\\n self.assertIn(attribute, dir(DatasetLoader_Jakob2019))\",\n \"def sanity_check(hdf):\\n required_paths = ['Analyses', 'UniqueGlobalKey', 'Analyses/EventDetection_000']\\n try:\\n for p in required_paths:\\n if p not in hdf:\\n return False\\n return True\\n except:\\n return False\",\n \"def readManifestFile(syn, manifestFile):\\n table.test_import_pandas()\\n import pandas as pd\\n\\n sys.stdout.write('Validation and upload of: %s\\\\n' % manifestFile)\\n # Read manifest file into pandas dataframe\\n df = pd.read_csv(manifestFile, sep='\\\\t')\\n if 'synapseStore' not in df:\\n df = df.assign(synapseStore=None)\\n df.synapseStore[df['path'].apply(is_url)] = False # override synapseStore values to False when path is a url\\n df.synapseStore[df['synapseStore'].isnull()] = True # remaining unset values default to True\\n df.synapseStore = df.synapseStore.astype(bool)\\n df = df.fillna('')\\n\\n sys.stdout.write('Validating columns of manifest...')\\n for field in REQUIRED_FIELDS:\\n sys.stdout.write('.')\\n if field not in df.columns:\\n sys.stdout.write('\\\\n')\\n raise ValueError(\\\"Manifest must contain a column of %s\\\" % field)\\n sys.stdout.write('OK\\\\n')\\n\\n sys.stdout.write('Validating that all paths exist')\\n df.path = df.path.apply(_check_path_and_normalize)\\n\\n sys.stdout.write('OK\\\\n')\\n\\n sys.stdout.write('Validating that all files are unique...')\\n if len(df.path) != len(set(df.path)):\\n raise ValueError(\\\"All rows in manifest must contain a unique file to upload\\\")\\n sys.stdout.write('OK\\\\n')\\n\\n sys.stdout.write('Validating provenance...')\\n df = _sortAndFixProvenance(syn, df)\\n sys.stdout.write('OK\\\\n')\\n\\n sys.stdout.write('Validating that parents exist and are containers...')\\n parents = set(df.parent)\\n for synId in parents:\\n try:\\n container = syn.get(synId, downloadFile=False)\\n except SynapseHTTPError:\\n sys.stdout.write('\\\\n%s in the parent column is not a valid Synapse Id\\\\n' % synId)\\n raise\\n if not is_container(container):\\n sys.stdout.write('\\\\n%s in the parent column is is not a Folder or Project\\\\n' % synId)\\n raise SynapseHTTPError\\n sys.stdout.write('OK\\\\n')\\n return df\",\n \"def count_missing_stats(manifest):\\n num_missing = 0\\n for element in manifest:\\n if element.missing_stats():\\n num_missing += 1\\n return num_missing\",\n \"def is_manifest_list(self):\\n return False\",\n \"def split_manifest(root_path, manifest_file_path):\\n\\n train_manifest = open(os.path.join(root_path,\\\"dataset\\\", \\\"train_manifest.txt\\\"), \\\"w+\\\")\\n test_manifest = open(os.path.join(root_path, \\\"dataset\\\",\\\"test_manifest.txt\\\"), \\\"w+\\\")\\n val_manifest = open(os.path.join(root_path,\\\"dataset\\\" ,\\\"valid_manifest.txt\\\"), \\\"w+\\\")\\n with open(os.path.join(root_path, manifest_file_path), 'r') as f:\\n data_manifest = f.read().strip().split('\\\\n')\\n data_len = len(data_manifest)\\n k = 0\\n for i in data_manifest:\\n if k == 0:\\n k = k+1\\n continue\\n elif k == 1:\\n train_manifest.write(i+'\\\\n')\\n test_manifest.write(i+'\\\\n')\\n val_manifest.write(i+'\\\\n')\\n elif k <= data_len*0.6: # 60% on train set\\n train_manifest.write(i+'\\\\n')\\n elif k > data_len*0.6 and k <= data_len*0.8: # 20 % on test\\n test_manifest.write(i+'\\\\n')\\n else: #20 % on test\\n val_manifest.write(i+'\\\\n')\\n k = k+1\\n print(\\\"Spliting attritutes Done!\\\")\",\n \"def test_is_valid_manifest_with_missing_md5_column(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_missing_md5_column.tsv\\\",\\n )\\n missing_md5_message = (\\n 'could not find a column name corresponding to required \\\"Columns.MD5\\\"'\\n )\\n assert missing_md5_message in caplog.text\\n assert result == False\",\n \"def verify_wilds(self):\\n self.check_dataset_duplicate_ids(self.wilds)\",\n \"def test_manifest(self):\\n self.parse_manifest()\\n\\n ids = {}\\n errors = []\\n collisions = []\\n manifest = self.cryptomattes[self.selection][\\\"names_to_IDs\\\"]\\n for name, idvalue in manifest.iteritems():\\n if mm3hash_float(name) != idvalue:\\n errors.append(\\\"computed ID doesn't match manifest ID: (%s, %s)\\\" % (idvalue, mm3hash_float(name)))\\n else:\\n if idvalue in ids:\\n collisions.append(\\\"colliding: %s %s\\\" % (ids[idvalue], name))\\n ids[idvalue] = name\\n\\n print \\\"Tested %s, %s names\\\" % (self.nuke_node.name(), len(manifest))\\n print \\\" \\\", len(errors), \\\"non-matching IDs between python and c++.\\\"\\n print \\\" \\\", len(collisions), \\\"hash collisions in manifest.\\\"\\n\\n return errors, collisions\",\n \"def test_sa_mismatch_manifest_file_and_ecosystem(self):\\n with open(str(Path(__file__).parent.parent.parent) +\\n '/data/manifests/202/npmlist.json', 'rb') as fp:\\n fs = FileStorage(stream=fp, filename='npmlist.json')\\n with pytest.raises(Exception) as exception:\\n sa_post_request = StackAnalysesPostRequest(manifest=fs, file_path='/tmp/bin',\\n ecosystem='pypi', show_transitive=True)\\n sa = StackAnalyses(sa_post_request)\\n sa.post_request()\\n self.assertIs(exception.type, ValidationError)\",\n \"def check_dataset(number_episode_dics):\\n\\n for env_name in number_episode_dics.keys():\\n\\n check_folder(env_name, number_episode_dics[env_name])\",\n \"def check_for_data():\\n if not (os.path.exists(ep.get_test_data_path()) or os.path.exists(ep.get_dbn_weight_path())):\\n return False\\n return True\",\n \"def test_is_valid_manifest_format_with_empty_url(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_empty_url.tsv\\\",\\n )\\n assert caplog.text == \\\"\\\"\\n assert result == True\",\n \"def check_unstructured(extractions):\\n if not extractions:\\n return True\\n for ext in extractions:\\n if not hasattr(ext, 'args'):\\n return False\\n return True\",\n \"def cross_validate(self, contents, required=None, forbidden=None):\\n if required:\\n for item in required:\\n self.assertTrue(\\n item in contents,\\n \\\"Required entry [{item}] not found in:\\\\n{contents}\\\".format(\\n item=item, contents=contents\\n )\\n )\\n if forbidden:\\n for item in forbidden:\\n self.assertTrue(\\n item not in contents,\\n \\\"Forbidden entry [{item}] found in:\\\\n{contents}\\\".format(\\n item=item, contents=contents\\n )\\n )\",\n \"def test_invalid_manifest_filepath(self):\\n load_manifest(\\\"./ehiiehaiehnatheita\\\")\",\n \"def _check_availability(self, names: Iterable) -> None:\\n unavailable = [x for x in names if x not in self.__by_name.keys()]\\n if unavailable:\\n raise ValueError(f'datasets: {unavailable} not available in the {self.region} region.')\",\n \"def check_dataset_exists(dataset):\\n result = subprocess.call(['das_client.py', '--query', 'dataset dataset=%s' % dataset])\\n return result == 0\",\n \"def _verify(self) -> None:\\n # Check if the files already exist\\n if os.path.exists(os.path.join(self.root, self.image_root)):\\n return\\n\\n # Check if .zip files already exists (if so extract)\\n exists = []\\n for filename, md5 in zip(self.filenames, self.md5s):\\n filepath = os.path.join(self.root, filename)\\n if os.path.isfile(filepath):\\n if self.checksum and not check_integrity(filepath, md5):\\n raise RuntimeError(\\\"Dataset found, but corrupted.\\\")\\n exists.append(True)\\n extract_archive(filepath)\\n else:\\n exists.append(False)\\n\\n if all(exists):\\n return\\n\\n # Check if the user requested to download the dataset\\n raise RuntimeError(\\n \\\"Dataset not found in `root` directory, either specify a different\\\"\\n + \\\" `root` directory or manually download the dataset to this directory.\\\"\\n )\",\n \"def check_data_struct():\\n if not os.path.exists(PROJECT_ROOT+'/data'):\\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), PROJECT_ROOT+'/data')\\n\\n if not os.path.exists(PROJECT_ROOT+'/data/CUB_200_2011'):\\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), PROJECT_ROOT+'/data/CUB_200_2011')\\n\\n if not os.path.exists(PROJECT_ROOT+'/data/segmentations'):\\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), PROJECT_ROOT+'/data/segmentations')\\n\\n if not os.path.exists(PROJECT_ROOT+'/data/attributes.txt'):\\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), PROJECT_ROOT+'/data/attributes.txt')\",\n \"def checkMetadata(self):\\n super(WorldfileMultiple, self).checkMetadata()\\n \\n # Check for necessary information in metadata\\n if not 'basin_rast' in self.grassMetadata:\\n raise MetadataException(\\\"Metadata in project directory %s does not contain a basin raster in a GRASS mapset\\\" % (self.context.projectDir,))\\n if not 'subbasins_rast' in self.grassMetadata:\\n raise MetadataException(\\\"Metadata in project directory %s does not contain a sub-basin raster in a GRASS mapset\\\" % (self.context.projectDir,))\\n if not 'dem_rast' in self.grassMetadata:\\n raise MetadataException(\\\"Metadata in project directory %s does not contain a DEM raster in a GRASS mapset\\\" % (self.context.projectDir,)) \\n if not 'soil_rast' in self.grassMetadata:\\n raise MetadataException(\\\"Metadata in project directory %s does not contain a soil raster in a GRASS mapset\\\" % (self.context.projectDir,))\\n if not 'patch_rast' in self.grassMetadata:\\n raise MetadataException(\\\"Metadata in project directory %s does not contain a patch raster in a GRASS mapset\\\" % (self.context.projectDir,))\\n \\n if not 'rhessys_dir' in self.metadata:\\n raise MetadataException(\\\"Metadata in project directory %s does not contain a RHESSys directory\\\" % (self.context.projectDir,))\\n if not 'g2w_bin' in self.metadata:\\n raise MetadataException(\\\"Metadata in project directory %s does not contain a grass2world executable\\\" % (self.context.projectDir,))\\n if not 'rat_bin' in self.metadata:\\n raise MetadataException(\\\"Metadata in project directory %s does not contain an AverageTables executable\\\" % (self.context.projectDir,))\\n if not 'template' in self.metadata:\\n raise MetadataException(\\\"Metadata in project directory %s does not contain a world template\\\" % (self.context.projectDir,))\\n if not 'rhessys_dir' in self.metadata:\\n raise MetadataException(\\\"Metadata in project directory {0} does not contain a RHESSys directory\\\".format(self.context.projectDir))\",\n \"def testGetManifest(self):\\n manifest = self.dl_object._GetManifest()\\n self.assertEqual(manifest.get('mediaType'),\\n 'application/vnd.docker.distribution.manifest.v2+json')\\n self.assertIn('layers', manifest)\",\n \"def test_existence_checking(self):\\n params = [f'2010-{num:0>2}' for num in range(1, 13)] # all month of 2010\\n for month in params:\\n with self.assertRaises(ValueError) as cm: # ValueError should be raised with proper message\\n download_data(month)\\n self.assertEqual(f'Dataset from {month} cannot be found on lichess.org', cm.exception.args[0], msg=month)\\n # check if error message was as expected\",\n \"def test_MergeManifests_missing_files():\\n d1 = dpack_pb2.DataPackage()\\n f1 = d1.file.add()\\n f1.relative_path = \\\"a\\\"\\n f1.comment = \\\"abc\\\"\\n d2 = dpack_pb2.DataPackage()\\n f2 = d2.file.add()\\n f2.relative_path = \\\"b\\\"\\n f2.comment = \\\"def\\\"\\n dpack.MergeManifests(d1, d2)\\n assert d1.file[0].comment == \\\"abc\\\"\\n assert d2.file[0].comment == \\\"def\\\"\",\n \"def has_required_programs(program_list):\\n \\n returnValue = True\\n \\n for program in program_list:\\n if commands.getstatusoutput(\\\"which \\\"+program)[0] != 0:\\n log.error(program+\\\" is required by \\\"+PROGRAM_NAME)\\n returnValue = False\\n \\n return returnValue\",\n \"def dataset_name_matches_in_xif_and_schema(self):\\n\\n def get_dataset_from_xif(xif_file_path: str) -> List[str]:\\n with open(xif_file_path) as xif_file:\\n xif_content = xif_file.read()\\n dataset = re.findall('dataset[ ]?=[ ]?([\\\"a-zA-Z_0-9]+)', xif_content)\\n if dataset:\\n return [dataset_name.strip('\\\"') for dataset_name in dataset]\\n return []\\n\\n xif_file_path = get_files_in_dir(\\n os.path.dirname(self.file_path), [\\\"xif\\\"], False\\n )\\n if xif_file_path and self.schema_content:\\n xif_datasets = set(get_dataset_from_xif(xif_file_path[0]))\\n schema_datasets = self.schema_content.keys()\\n if len(xif_datasets) == len(schema_datasets) and len(xif_datasets) >= 1:\\n all_exist = all(dataset in schema_datasets for dataset in xif_datasets)\\n if all_exist:\\n return True\\n\\n error_message, error_code = Errors.modeling_rule_schema_xif_dataset_mismatch()\\n if self.handle_error(error_message, error_code, file_path=self.file_path):\\n self._is_valid = False\\n return False\",\n \"def test_index_manifest_packages_failure(data, gen3_index, gen3_auth, logfile):\\n with patch(\\n \\\"gen3.tools.indexing.index_manifest.Gen3Metadata.create\\\", MagicMock()\\n ) as mock_mds_create:\\n index_object_manifest(\\n manifest_file=f\\\"{CURRENT_DIR}/test_data/{data['manifest']}\\\",\\n auth=gen3_auth,\\n commons_url=gen3_index.client.url,\\n thread_num=1,\\n replace_urls=False,\\n submit_additional_metadata_columns=True,\\n )\\n mds_records = {\\n kwargs[\\\"guid\\\"]: kwargs[\\\"metadata\\\"]\\n for (_, kwargs) in mock_mds_create.call_args_list\\n }\\n assert len(mds_records) == 0\\n\\n indexd_records = {r[\\\"did\\\"]: r for r in gen3_index.get_all_records()}\\n assert len(indexd_records) == 0\\n\\n for error in data[\\\"expected_error_msgs\\\"]:\\n assert error in logfile.read()\",\n \"def exists_dataset(self, dataset):\\n assert dataset, \\\"Must input a valid dataset name.\\\"\\n return any(self.get_by_dataset(dataset))\",\n \"def check_dataset_presence(dataset, verbose=False):\\n quantities = ['name', 'dataset_fraction', 'replica_fraction', 'block_fraction', 'block_completion']\\n\\n # Get site name and fractions for each site\\n # yes, you prob shouldn't use shell=True, but CBA to figure out how to split the string for das_client\\n grep_str = ' '.join(['site.%s' % q for q in quantities])\\n out = check_output('das_client --query=\\\"site dataset=%s | grep %s\\\"' % (dataset, grep_str), shell=True)\\n\\n site_dicts = [] # hold info about each site\\n\\n # Process the important lines, store in a dict for each site\\n results = [x for x in out.split('\\\\n') if 'Showing' not in x and x != '']\\n for line in results:\\n # Don't care if it's at a T1\\n if line.startswith('T1'):\\n continue\\n sdict = {q : p for q, p in zip(quantities, line.split())}\\n site_dicts.append(sdict)\\n\\n if verbose:\\n # Print output for each site with fractions, colour coded\\n print TColour.BLUE, dataset, TColour.ENDC\\n print '\\\\t %s' % ' - '.join(quantities)\\n for sdict in site_dicts:\\n fracs = [sdict[k] for k in quantities]\\n status_col = TColour.RED\\n if all([f == '100.00%' for f in fracs if not f.startswith('T')]):\\n status_col = TColour.GREEN\\n print '\\\\t', status_col, ' - '.join(fracs), TColour.ENDC\\n else:\\n # Figure out if fully transferred anywhere, in which case print in green\\n transferred = False\\n for sdict in site_dicts:\\n fracs = [sdict[k] for k in quantities]\\n if all([f == '100.00%' for f in fracs if not f.startswith('T')]):\\n transferred = True\\n break\\n\\n status_col = TColour.GREEN if transferred else TColour.RED\\n status_letter = 'v' if transferred else 'x'\\n print status_col, status_letter, dataset, TColour.ENDC\",\n \"def test_is_valid_manifest_format_using_error_on_empty_url(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_empty_url.tsv\\\",\\n error_on_empty_url=True,\\n )\\n assert '\\\"\\\"' in caplog.text\\n assert result == False\",\n \"def test_no_updated_datasets(self):\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n for dataset in self.datasets_v3:\\n self.assertNotIn(dataset, table.data)\",\n \"def test_is_valid_manifest_format_with_invalid_authz_resources(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_invalid_authz_resources.tsv\\\",\\n )\\n error_log = caplog.text\\n assert '\\\"invalid_authz\\\"' in error_log\\n assert '\\\"/\\\"' in error_log\\n assert '\\\"//\\\"' in error_log\\n assert '\\\"///\\\"' in error_log\\n assert '\\\"invalid_authz2\\\"' in error_log\\n assert result == False\",\n \"def requirement_missing(script):\\n if \\\"requires\\\" in script:\\n if script[\\\"requires\\\"] is None:\\n return False\\n for package in script[\\\"requires\\\"].split():\\n try:\\n pkg_resources.working_set.require(package)\\n except Exception:\\n return True\\n return False\",\n \"def check_structured(extractions):\\n if not extractions:\\n return True\\n for ext in extractions:\\n if not hasattr(ext, 'arg1'):\\n return False\\n return True\",\n \"def is_empty(self):\\n for key, dataset in self.datasets.items():\\n try:\\n has_data = dataset.has_data()\\n except MFDataException as mfde:\\n raise MFDataException(\\n mfdata_except=mfde,\\n model=self._container_package.model_name,\\n package=self._container_package._get_pname(),\\n message=\\\"Error occurred while verifying\\\"\\n ' data of dataset \\\"{}\\\" in block '\\n '\\\"{}\\\"'.format(dataset.structure.name, self.structure.name),\\n )\\n\\n if has_data is not None and has_data:\\n return False\\n return True\",\n \"def test_with_valid_input(self):\\n for dataset_type in ['regular', 'raw', 'REGULAR', 'RAW']:\\n try:\\n check_dataset_type(dataset_type)\\n except ValueError:\\n self.fail(\\\"Dataset {0} should be valid\\\".format(dataset_type))\",\n \"def test_is_valid_manifest_with_wide_row(caplog):\\n logging.getLogger().setLevel(logging.WARNING)\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_wide_row.tsv\\\",\\n )\\n wide_warning = f\\\"line 3, number of fields (6) in row is unequal to number of column names in manifest (5)\\\"\\n assert wide_warning in caplog.text\\n assert result == True\",\n \"def _validate_manifest(self, kind, source, cls=None, **kwargs):\\n data = self._load_json(kind, source, **kwargs)\\n\\n # TODO elegant way of cleaning up this nasty serialisation hack to manage conversion of outbound manifests to primitive\\n inbound = True\\n if hasattr(data, \\\"to_primitive\\\"):\\n inbound = False\\n data = data.to_primitive()\\n\\n self._validate_against_schema(kind, data)\\n self._validate_all_expected_datasets_are_present_in_manifest(manifest_kind=kind, manifest=data)\\n\\n if cls and inbound:\\n return cls(**data)\\n\\n return data\",\n \"def test_metadata_atleast_latin_menu_subsets_exist(self):\\n self.assertIn('menu', self.metadata.get('subsets', []),\\n msg=\\\"Subsets missing menu\\\")\\n self.assertIn('latin', self.metadata.get('subsets', []),\\n msg=\\\"Subsets missing latin\\\")\",\n \"def validate_manifest(\\n request: ValidateManifestRequest = Body(...),\\n schema: Any = Depends(get_description_schema),\\n) -> ValidateManifestResponse:\\n\\n _, response = _validate_manifest(request, schema)\\n return response\",\n \"def checkIfThereIsData(self, i):\\n _, amountOfThings = self.weaviate.Get(\\\"/\\\" + i)\\n if len(amountOfThings[i]) == 0:\\n return False\\n else:\\n return True\",\n \"def _check_manifest_resources(self, documents: list) -> str:\\n for doc in documents:\\n kind = doc.get(\\\"kind\\\")\\n\\n # If this kind defines a job template, pull it out\\n if kind in JOB_TEMPLATE_RESOURCES:\\n doc = doc.get(\\\"spec\\\").get(\\\"jobTemplate\\\")\\n if doc is None:\\n return f\\\"{kind} resources MUST specify a job template!\\\"\\n\\n if kind in POD_TEMPLATE_RESOURCES:\\n pod_template = doc.get(\\\"spec\\\").get(\\\"template\\\")\\n if pod_template is None:\\n return f\\\"{kind} resources MUST specify a pod template!\\\"\\n\\n pod_spec = pod_template.get(\\\"spec\\\")\\n if pod_spec is None:\\n return f\\\"{kind} resources MUST specify a pod spec!\\\"\\n\\n containers = pod_spec.get(\\\"containers\\\")\\n if not containers:\\n return f\\\"{kind} resources MUST specify at least one container!\\\"\\n\\n init_containers = pod_spec.get(\\\"initContainers\\\")\\n if init_containers:\\n containers = containers + init_containers\\n\\n missing_resources_msg = (\\n f\\\"All containers and initContainers in a {kind}\\\"\\n \\\"must define resource constraints!\\\"\\n )\\n for cont in containers:\\n resources = cont.get(\\\"resources\\\")\\n if not resources:\\n return missing_resources_msg\\n\\n limits = resources.get(\\\"limits\\\")\\n if not limits or not limits.get(\\\"cpu\\\") or not limits.get(\\\"memory\\\"):\\n return missing_resources_msg\\n\\n requests = resources.get(\\\"requests\\\")\\n if (\\n not requests\\n or not requests.get(\\\"cpu\\\")\\n or not requests.get(\\\"memory\\\")\\n ):\\n return missing_resources_msg\",\n \"def test_check_metadata_fields(self):\\n contents = self.read_metadata_contents()\\n family = Metadata.get_family_metadata(contents)\\n\\n keys = [(\\\"name\\\", str), (\\\"postScriptName\\\", str),\\n (\\\"fullName\\\", str), (\\\"style\\\", str),\\n (\\\"weight\\\", int), (\\\"filename\\\", str),\\n (\\\"copyright\\\", str)]\\n\\n missing = set([])\\n unknown = set([])\\n\\n for j, itemtype in keys:\\n\\n for font_metadata in family.fonts:\\n if j not in font_metadata:\\n missing.add(j)\\n\\n for k in font_metadata:\\n if k not in map(lambda x: x[0], keys):\\n unknown.add(k)\\n\\n if unknown:\\n msg = 'METADATA.json \\\"fonts\\\" property has unknown items [%s]'\\n self.fail(msg % ', '.join(unknown))\\n\\n if missing:\\n msg = 'METADATA.json \\\"fonts\\\" property items missed [%s] items'\\n self.fail(msg % ', '.join(missing))\",\n \"def check_dataset_files_outside_datadir(fix, dataset_gateway: IDatasetGateway, **_):\\n invalid_files = []\\n for dataset in dataset_gateway.get_provenance_tails():\\n if dataset.date_removed:\\n continue\\n\\n data_dir = dataset.get_datadir()\\n\\n detected_files = []\\n\\n for file in dataset.files:\\n if file.is_external or file.linked:\\n continue\\n try:\\n get_safe_relative_path(project_context.path / file.entity.path, project_context.path / data_dir)\\n except ValueError:\\n detected_files.append(file)\\n\\n if not detected_files:\\n continue\\n\\n if fix:\\n communication.info(f\\\"Fixing dataset '{dataset.name}' files.\\\")\\n dataset.unfreeze()\\n for file in detected_files:\\n dataset.unlink_file(file.entity.path)\\n dataset.freeze()\\n add_to_dataset(dataset.name, urls=[file.entity.path for file in detected_files], link=True)\\n else:\\n invalid_files.extend(detected_files)\\n\\n if invalid_files:\\n problems = (\\n WARNING\\n + \\\"There are dataset files that aren't inside their dataset's data directory \\\"\\n + \\\"(use 'renku doctor --fix' to fix them):\\\\n\\\\n\\\\t\\\"\\n + \\\"\\\\n\\\\t\\\".join(click.style(file.entity.path, fg=\\\"yellow\\\") for file in invalid_files)\\n + \\\"\\\\n\\\"\\n )\\n return False, True, problems\\n\\n return True, False, None\",\n \"def is_manifest(location):\\n return as_posixpath(location).lower().endswith('meta-inf/manifest.mf')\",\n \"def _dist_has_meta_data(dist: pkg_resources.Distribution) -> bool:\\n return dist.has_metadata('direct_url.json')\",\n \"def test_compatible_data_presence(allparams):\\n compatible_data_keys_set = set(['puf', 'cps'])\\n\\n # Nested function used only in test_compatible_data_presence\\n def valid_compatible_data(compatible_data):\\n \\\"\\\"\\\"\\n Return True if compatible_data is a valid dictionary;\\n otherwise return False\\n \\\"\\\"\\\"\\n if not isinstance(compatible_data, dict):\\n return False\\n if set(compatible_data.keys()) != compatible_data_keys_set:\\n return False\\n for key in compatible_data:\\n boolean = (compatible_data[key] is True or\\n compatible_data[key] is False)\\n if not boolean:\\n return False\\n return True\\n\\n # Main logic of test_compatible_data_presence function\\n problem_pnames = list()\\n for pname in allparams:\\n if 'compatible_data' in allparams[pname]:\\n compatible_data = allparams[pname]['compatible_data']\\n else:\\n compatible_data = None\\n if not valid_compatible_data(compatible_data):\\n problem_pnames.append(pname)\\n if problem_pnames:\\n msg = '{} has no or invalid compatible_data field'\\n for pname in problem_pnames:\\n print(msg.format(pname))\\n assert 'list of problem_pnames' == 'empty list'\",\n \"def check_expected_present(self, data, expected, premessage):\\n # check missing\\n missing = list(d for d in expected if d not in data)\\n if missing:\\n self.raiseAWarning(premessage, '| Expected variables are missing:', missing)\\n # check None\\n nones = list(d for d, v in data.items() if (v is None and v in expected))\\n if nones:\\n self.raiseAWarning(premessage, '| Expected variables are None:', nones)\\n if missing or nones:\\n self.raiseAnError(RuntimeError, 'Some variables were missing or None! See warning messages above for details!')\",\n \"def exists():\\n check50.include(\\\"data\\\")\\n check50.exists(\\\"adventure.py\\\")\\n check50.exists(\\\"room.py\\\")\",\n \"def test_incorrect_dependency(self):\\n load_manifest(StringIO(manifest_incorrect_dependency))\",\n \"def has_extras(self):\\n return any(map(utils.assert_package_has_extras, self.pkg_arguments))\",\n \"def _verify(self) -> None:\\n # Check if the extracted files already exist\\n pathname = os.path.join(self.root, self.data_dir)\\n if os.path.exists(pathname):\\n return\\n\\n # Check if the zip files have already been downloaded\\n pathname = os.path.join(self.root, self.data_dir) + \\\".zip\\\"\\n if os.path.exists(pathname):\\n self._extract()\\n return\\n\\n # Check if the user requested to download the dataset\\n if not self.download:\\n raise RuntimeError(\\n f\\\"Dataset not found in `root={self.root}` and `download=False`, \\\"\\n \\\"either specify a different `root` directory or use `download=True` \\\"\\n \\\"to automatically download the dataset.\\\"\\n )\\n\\n # Download the dataset\\n self._download()\\n self._extract()\",\n \"def check_data():\\n check_docs(\\\"Training\\\")\\n check_docs(\\\"dev\\\")\\n check_docs(\\\"Test\\\")\",\n \"def validate_dataset(self):\\n pass\",\n \"def test_sanity(self):\\n\\n parser = ManifestParser()\\n mozmill_example = os.path.join(here, 'mozmill-example.ini')\\n parser.read(mozmill_example)\\n tests = parser.tests\\n self.assertEqual(len(tests), len(file(mozmill_example).read().strip().splitlines()))\\n\\n # Ensure that capitalization and order aren't an issue:\\n lines = ['[%s]' % test['name'] for test in tests]\\n self.assertEqual(lines, file(mozmill_example).read().strip().splitlines())\\n\\n # Show how you select subsets of tests:\\n mozmill_restart_example = os.path.join(here, 'mozmill-restart-example.ini')\\n parser.read(mozmill_restart_example)\\n restart_tests = parser.get(type='restart')\\n self.assertTrue(len(restart_tests) < len(parser.tests))\\n self.assertEqual(len(restart_tests), len(parser.get(manifest=mozmill_restart_example)))\\n self.assertFalse([test for test in restart_tests\\n if test['manifest'] != os.path.join(here, 'mozmill-restart-example.ini')])\\n self.assertEqual(parser.get('name', tags=['foo']),\\n ['restartTests/testExtensionInstallUninstall/test2.js',\\n 'restartTests/testExtensionInstallUninstall/test1.js'])\\n self.assertEqual(parser.get('name', foo='bar'),\\n ['restartTests/testExtensionInstallUninstall/test2.js'])\",\n \"def _validate_data(self):\\n logger.debug(\\\"Validating directory\\\")\\n root = self.data_dir\\n for path in self._walk_cases():\\n print(path)\\n full_path = os.path.join(root, path)\\n logger.debug(\\\" \\\" + full_path)\\n try:\\n assert os.path.exists(full_path)\\n except AssertionError:\\n raise AssertionError(\\n \\\"Couldn't find data on path {}\\\".format(full_path)\\n )\",\n \"def _validate_num_profiles(self):\\n for fp in [self.solar_fpath, self.wind_fpath]:\\n with Resource(fp) as res:\\n profile_dset_names = [\\n n for n in res.dsets\\n if self.__profile_reg_check.match(n)\\n ]\\n if not profile_dset_names:\\n msg = (\\\"Did not find any data sets matching the regex: \\\"\\n \\\"{!r} in {!r}. Please ensure that the profile data \\\"\\n \\\"exists and that the data set is named correctly.\\\")\\n e = msg.format(PROFILE_DSET_REGEX, fp)\\n logger.error(e)\\n raise FileInputError(e)\\n elif len(profile_dset_names) > 1:\\n msg = (\\\"Found more than one profile in {!r}: {}. \\\"\\n \\\"This module is not intended for hybridization of \\\"\\n \\\"multiple representative profiles. Please re-run \\\"\\n \\\"on a single aggregated profile.\\\")\\n e = msg.format(fp, profile_dset_names)\\n logger.error(e)\\n raise FileInputError(e)\\n else:\\n self.profile_dset_names += profile_dset_names\",\n \"def _detect_files(data):\\n return any(attr[\\\"extra\\\"].get(\\\"files\\\")\\n for attr in data[\\\"attributes\\\"] if attr[\\\"extra\\\"])\",\n \"def validate_input_manifest(self, source, **kwargs):\\n return self._validate_manifest(\\\"input_manifest\\\", source, **kwargs)\",\n \"def validate_available(parser, options):\\n if not options.available:\\n return\\n\\n if not options.manifest_id:\\n parser.error(\\\"When specifying --available, --manifest-id is also required\\\")\",\n \"def test_talbot_manifest_fetch():\\n request, response = app.test_client.get(\\\"/iiif/manifest/452d6b51-949c-447d-9880-1108ffdfd96e.json\\\")\\n assert response.status == 200\",\n \"def test_check_presence_only(self):\\n schema = yaml.load(self.yaml_presence_check, Loader=yaml.FullLoader)\\n val = DwcaValidator(schema, allow_unknown=True,\\n error_handler=WhipErrorHandler)\\n\\n document = {'abundance': 'many'}\\n self.assertTrue(val.validate(document))\\n document = {'abundance': ''}\\n self.assertTrue(val.validate(document))\\n document = {'eventDate': ''}\\n val.validate(document)\\n self.assertEqual(val.errors, {})\",\n \"def check_ekin_dataset(cls, ekindatasets):\\n for k in ekindatasets.keys():\\n ekindataset = ekindatasets[k]\\n xdatapoints=ekindataset[0].keys()\\n count=0\\n for datapoint in xdatapoints:\\n if datapoint=='label' or datapoint=='label_widget':\\n continue\\n else:\\n if not isinstance(ekindataset[0][datapoint], dict):\\n if ekindataset[0][datapoint] != '':\\n return 1\\n elif ekindataset[0][datapoint].has_key('var'):\\n if ekindataset[0][datapoint]['var']!='':\\n return 1\\n return 0\",\n \"def check_missing_files(dataset_gateway: IDatasetGateway, **_):\\n missing = defaultdict(list)\\n\\n for dataset in dataset_gateway.get_all_active_datasets():\\n # NOTE: Datasets with storage backend don't have local copies of files\\n if dataset.storage:\\n continue\\n for file_ in dataset.files:\\n path = project_context.path / file_.entity.path\\n file_exists = path.exists() or (file_.is_external and os.path.lexists(path))\\n if not file_exists:\\n missing[dataset.name].append(file_.entity.path)\\n\\n if not missing:\\n return True, False, None\\n\\n problems = WARNING + \\\"There are missing files in datasets.\\\"\\n\\n for dataset_name, files in missing.items():\\n problems += (\\n \\\"\\\\n\\\\t\\\"\\n + click.style(dataset_name, fg=\\\"yellow\\\")\\n + \\\":\\\\n\\\\t \\\"\\n + \\\"\\\\n\\\\t \\\".join(click.style(path, fg=\\\"red\\\") for path in files)\\n )\\n\\n return False, False, problems\",\n \"def test_is_valid_manifest_format_with_invalid_md5_values(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_invalid_md5_values.tsv\\\"\\n )\\n\\n error_log = caplog.text\\n manifest_with_invalid_md5_values_helper(error_log)\\n base64_encoded_md5 = '\\\"jd2L5LF5pSmvpfL/rkuYWA==\\\"'\\n assert base64_encoded_md5 in error_log\\n assert result == False\",\n \"def _check_variables(datasets, necessary_short_names):\\n dataset_name = datasets[0]['dataset']\\n necessary_short_names = set(necessary_short_names)\\n short_names = set(group_metadata(datasets, 'short_name').keys())\\n if short_names != necessary_short_names:\\n raise ValueError(\\n f\\\"Expected variables {necessary_short_names} for dataset \\\"\\n f\\\"'{dataset_name}', got {short_names}\\\")\",\n \"def check_existing_dataset(path: str):\\n x_path = os.path.join(path, IMG_DIR)\\n y_path = os.path.join(path, MSK_DIR)\\n\\n if os.path.isdir(x_path) and os.path.isdir(y_path):\\n _, _, x_files = next(os.walk(x_path))\\n _, _, y_files = next(os.walk(y_path))\\n x = len(x_files)\\n y = len(y_files)\\n\\n if x != y:\\n logger.warning(\\n \\\"Found un-even numbers of x-y for dataset. x = %i, y = %i.\\\", x, y\\n )\\n\\n return -1\\n\\n if x == 0:\\n logger.info(\\\"Found 0 existing sets.\\\")\\n\\n return 0\\n logger.info(\\\"Found %s sets in existing dataset.\\\", x)\\n\\n return x\\n logger.error(\\\"Could not locate x and y folder.\\\")\\n sys.exit()\",\n \"def test_is_valid_manifest_format_with_invalid_sizes(caplog):\\n result = is_valid_manifest_format(\\n \\\"tests/validate_manifest_format/manifests/manifest_with_invalid_sizes.tsv\\\"\\n )\\n error_log = caplog.text\\n assert \\\"-1\\\" in error_log\\n assert \\\"not_an_int\\\" in error_log\\n assert \\\"3.34\\\" in error_log\\n assert \\\"string_with_42\\\" in error_log\\n assert result == False\",\n \"def test_exist_entry_on_rebuild(self):\\n self.validate_attributes_in_exist_response()\",\n \"def is_dataset(X, require_attrs=None):\\n\\n if require_attrs is None:\\n require_attrs = [\\\"data_vars\\\", \\\"coords\\\", \\\"dims\\\", \\\"to_array\\\"]\\n\\n return all([hasattr(X, name) for name in require_attrs])\",\n \"def _check_dataset_consistency(self):\\n if not self.multi_dataset: \\n raise MutantError(\\\"_check_dataset_consistency only makes sense for multi-datasets!\\\")\\n def _check_sets_raise_error(set1, set2, set1_name, set2_name):\\n if not set1==set2:\\n raise MutantError(\\\"Multi-dataset mutant pool has different %s and %s dataset sets! %s, %s\\\"%(set1_name, \\n set2_name, set1, set2))\\n datasets_from_summary = set(self.summary.keys())\\n datasets_from_mutants = set.union(*[set(m.by_dataset.keys()) for m in self])\\n _check_sets_raise_error(datasets_from_summary, datasets_from_mutants, \\\"from summary\\\", \\\"from mutants\\\")\\n try:\\n if self._dataset_order is not None: \\n datasets_from_order = set(self._dataset_order)\\n _check_sets_raise_error(datasets_from_order, datasets_from_summary, \\\"from dataset_order\\\", \\\"from summary\\\")\\n except AttributeError:\\n pass\",\n \"def check_image_manifest(self,\\n idf,\\n cids,\\n cols = ['md5sum',\\n 'storage_urls',\\n 'file_size',\\n 'case_ids',\\n 'study_uid',\\n 'series_uid',\\n 'file_name']):\\n errors = []\\n for col in cols:\\n missing = len(idf[idf[col].isnull()])\\n if missing > 0:\\n error = \\\"'{}' values issing for image manifest column '{}'.\\\".format(len(missing),col)\\n print(error)\\n errors.append(error)\\n if \\\"case_ids\\\" in idf:\\n icids = list(set(idf[\\\"case_ids\\\"]))\\n extra_cids = list(set(icids).difference(cids))\\n if len(extra_cids) > 0:\\n error = \\\"The image manifest TSV contains {} case IDs that are not present in the case TSV!\\\".format(len(extra_cids))\\n print(error)\\n errors.append(error)\\n else:\\n error = \\\"'case_ids' column missing from image manifest!\\\"\\n print(error)\\n errors.append(error)\\n return errors\",\n \"def _check_integrity(self):\\n root = self.root\\n for scene_name in self.scene_list:\\n if not(os.path.isdir(os.path.join(root,scene_name)) and \\n os.path.isdir(os.path.join(root,scene_name, images_dir)) and\\n os.path.isfile(os.path.join(root,scene_name,annotation_filename))):\\n return False\\n return True\",\n \"def _check_integrity(self):\\n root = self.root\\n for scene_name in self.scene_list:\\n if not(os.path.isdir(os.path.join(root,scene_name)) and \\n os.path.isdir(os.path.join(root,scene_name, images_dir)) and\\n os.path.isfile(os.path.join(root,scene_name,annotation_filename))):\\n return False\\n return True\",\n \"def check_invalid_datasets_derivation(fix, dataset_gateway: IDatasetGateway, **_):\\n invalid_datasets = []\\n\\n def fix_or_report(dataset):\\n if fix:\\n dataset.unfreeze()\\n dataset.derived_from = None\\n dataset.freeze()\\n communication.info(f\\\"Fixing dataset '{dataset.name}'\\\")\\n else:\\n invalid_datasets.append(dataset.name)\\n\\n for dataset in dataset_gateway.get_provenance_tails():\\n while dataset.derived_from is not None and dataset.derived_from.url_id is not None:\\n if dataset.same_as or dataset.derived_from.url_id == dataset.id:\\n fix_or_report(dataset)\\n break\\n\\n try:\\n dataset = dataset_gateway.get_by_id(dataset.derived_from.url_id)\\n except errors.ObjectNotFoundError:\\n fix_or_report(dataset)\\n break\\n\\n if not invalid_datasets:\\n return True, False, None\\n\\n problems = (\\n WARNING\\n + \\\"There are invalid dataset metadata in the project (use 'renku doctor --fix' to fix them):\\\"\\n + \\\"\\\\n\\\\n\\\\t\\\"\\n + \\\"\\\\n\\\\t\\\".join(click.style(name, fg=\\\"yellow\\\") for name in invalid_datasets)\\n + \\\"\\\\n\\\"\\n )\\n\\n return False, True, problems\",\n \"def _check_data_valid(self):\\n\\n is_valid = (sum(~np.isnan(self.data).flatten()) > 0 and self.data.flatten().sum() != 0)\\n if not is_valid:\\n raise FITSException(f\\\"No data in {self.survey}\\\")\",\n \"def check(self):\\n missing = []\\n for name in self.data[\\\"locations\\\"]:\\n try:\\n n = self.data[\\\"names\\\"][name]\\n except KeyError:\\n missing.append(name)\\n if missing:\\n raise RuntimeError(\\\"\\\\\\\"names\\\\\\\" list lacks:\\\\n \\\" + \\\"\\\\n \\\".join(missing))\",\n \"def needs_dataset(*names, default=None):\\n non_ion_datasets = ['abundance', 'ip', 'ioneq']\\n names = [f'_{n}' if n not in non_ion_datasets else f'{n}' for n in names]\\n\\n def decorator(func):\\n @wraps(func)\\n def func_wrapper(*args, **kwargs):\\n if any([args[0].__getattribute__(n) is None for n in names]):\\n return default\\n else:\\n return func(*args, **kwargs)\\n return func_wrapper\\n return decorator\",\n \"def test_no_removed_datasets(self):\\n removed_dataset_1 = factories.SourceDatasetFactory.create(source_study_version=self.study_version_1)\\n removed_dataset_2 = factories.SourceDatasetFactory.create(\\n source_study_version=self.study_version_2, i_accession=removed_dataset_1.i_accession)\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n self.assertNotIn(removed_dataset_1, table.data)\\n self.assertNotIn(removed_dataset_2, table.data)\\n self.assertEqual(len(table.data), 0)\",\n \"def isFilePresent(fileName):\\n global dataFolder,blackListFiles\\n allDataFiles = [f for f in listdir(dataFolder) if (isfile(join(dataFolder, f)) and f.endswith('.zip'))]\\n return fileName in allDataFiles and not (fileName in blackListFiles)\",\n \"def _CheckFileExistsWithData(self, logs, graph):\\n self.assertTrue(graph in logs, 'File %s was not output.' % graph)\\n self.assertTrue(logs[graph], 'File %s did not contain data.' % graph)\",\n \"def test_get_manifest(self):\\n expected_start, expected_end = self.mock_data.month_range.split(\\\"-\\\")\\n\\n manifest, _ = self.downloader._get_manifest(self.mock_data.test_date)\\n\\n self.assertEqual(manifest.get(\\\"assemblyId\\\"), self.mock_data.export_uuid)\\n self.assertEqual(manifest.get(\\\"reportKeys\\\"), [self.mock_data.export_file])\\n self.assertEqual(manifest.get(\\\"Compression\\\"), \\\"PLAIN\\\")\\n self.assertEqual(manifest.get(\\\"billingPeriod\\\").get(\\\"start\\\"), expected_start)\\n self.assertEqual(manifest.get(\\\"billingPeriod\\\").get(\\\"end\\\"), expected_end)\",\n \"def verify_entry(b):\\n for f in minimalfields:\\n if f not in b:\\n return False\\n return True\",\n \"def check_integrity(self) -> None:\\n for subset in self.subsets:\\n if not self._check_subset_integrity(subset):\\n raise ValueError(f\\\"subset {subset} not found or corrupt\\\")\",\n \"def check_missing_files(self):\\n files = [getattr(self, attr) for attr in self._required]\\n try:\\n utilities.check_missing_files(files)\\n except utilities.MissingConstraintError as err:\\n err.message += \\\"\\\\nSkipping {}\\\\n\\\".format(self.__class__.__name__)\\n raise err\",\n \"def get_manifest_data(bucket,team, dataset,manifest_key):\\n dynamo_config = DynamoConfiguration()\\n dynamo_interface = DynamoInterface(dynamo_config)\\n s3_interface = S3Interface()\\n local_path = s3_interface.download_object(bucket, manifest_key)\\n ddb_keys=[]\\n items=[]\\n with open(local_path, \\\"r\\\") as raw_file:\\n file_names = [file_name.strip().split(\\\"/\\\")[-1]\\n for file_name in raw_file]\\n for file in file_names:\\n ddb_keys.append({\\n \\\"dataset_name\\\": team+\\\"-\\\"+dataset,\\n \\\"manifest_file_name\\\": manifest_key.split(\\\"/\\\")[-1], \\\"datafile_name\\\": file\\n })\\n for ddb_key in ddb_keys:\\n try:\\n items.append(dynamo_interface.get_item_from_manifests_control_table(\\n ddb_key[\\\"dataset_name\\\"], ddb_key[\\\"manifest_file_name\\\"], ddb_key[\\\"datafile_name\\\"]))\\n except KeyError:\\n logger.error(\\\"The manifest file has not been processed in Stage A\\\")\\n raise Exception(\\\"Manifest File has not been processed in Stage A\\\")\\n\\n return items\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68781096","0.5914848","0.5894921","0.58664596","0.5797446","0.5790559","0.575301","0.57257426","0.56155634","0.5589998","0.55779296","0.5571627","0.55710405","0.5568376","0.55295604","0.5499033","0.5491544","0.5466877","0.54596764","0.5446938","0.54257554","0.5356052","0.533595","0.5322388","0.5315691","0.5311172","0.5294386","0.5277329","0.52738976","0.52700686","0.5246219","0.52426744","0.5232312","0.52162683","0.52074647","0.5203824","0.51894635","0.51869464","0.517388","0.5173813","0.51704115","0.51655155","0.51499987","0.51427585","0.5139918","0.51379037","0.5133375","0.5124356","0.5113062","0.51105046","0.5108641","0.5107189","0.51001096","0.5097492","0.50935715","0.50910616","0.5078984","0.50726235","0.50709295","0.50663847","0.5066297","0.5060553","0.5056738","0.5053627","0.50475043","0.50458884","0.5034705","0.5032661","0.50280607","0.50097257","0.50054884","0.50051874","0.5002973","0.5001303","0.49932414","0.49870738","0.49865437","0.49675947","0.49650425","0.49643654","0.49510133","0.4949947","0.49473888","0.49438706","0.4939257","0.49361664","0.4929928","0.4929928","0.4929879","0.49209255","0.49160096","0.4913835","0.49129403","0.49121457","0.48999614","0.48975095","0.48974168","0.48956493","0.48917636","0.48802915"],"string":"[\n \"0.68781096\",\n \"0.5914848\",\n \"0.5894921\",\n \"0.58664596\",\n \"0.5797446\",\n \"0.5790559\",\n \"0.575301\",\n \"0.57257426\",\n \"0.56155634\",\n \"0.5589998\",\n \"0.55779296\",\n \"0.5571627\",\n \"0.55710405\",\n \"0.5568376\",\n \"0.55295604\",\n \"0.5499033\",\n \"0.5491544\",\n \"0.5466877\",\n \"0.54596764\",\n \"0.5446938\",\n \"0.54257554\",\n \"0.5356052\",\n \"0.533595\",\n \"0.5322388\",\n \"0.5315691\",\n \"0.5311172\",\n \"0.5294386\",\n \"0.5277329\",\n \"0.52738976\",\n \"0.52700686\",\n \"0.5246219\",\n \"0.52426744\",\n \"0.5232312\",\n \"0.52162683\",\n \"0.52074647\",\n \"0.5203824\",\n \"0.51894635\",\n \"0.51869464\",\n \"0.517388\",\n \"0.5173813\",\n \"0.51704115\",\n \"0.51655155\",\n \"0.51499987\",\n \"0.51427585\",\n \"0.5139918\",\n \"0.51379037\",\n \"0.5133375\",\n \"0.5124356\",\n \"0.5113062\",\n \"0.51105046\",\n \"0.5108641\",\n \"0.5107189\",\n \"0.51001096\",\n \"0.5097492\",\n \"0.50935715\",\n \"0.50910616\",\n \"0.5078984\",\n \"0.50726235\",\n \"0.50709295\",\n \"0.50663847\",\n \"0.5066297\",\n \"0.5060553\",\n \"0.5056738\",\n \"0.5053627\",\n \"0.50475043\",\n \"0.50458884\",\n \"0.5034705\",\n \"0.5032661\",\n \"0.50280607\",\n \"0.50097257\",\n \"0.50054884\",\n \"0.50051874\",\n \"0.5002973\",\n \"0.5001303\",\n \"0.49932414\",\n \"0.49870738\",\n \"0.49865437\",\n \"0.49675947\",\n \"0.49650425\",\n \"0.49643654\",\n \"0.49510133\",\n \"0.4949947\",\n \"0.49473888\",\n \"0.49438706\",\n \"0.4939257\",\n \"0.49361664\",\n \"0.4929928\",\n \"0.4929928\",\n \"0.4929879\",\n \"0.49209255\",\n \"0.49160096\",\n \"0.4913835\",\n \"0.49129403\",\n \"0.49121457\",\n \"0.48999614\",\n \"0.48975095\",\n \"0.48974168\",\n \"0.48956493\",\n \"0.48917636\",\n \"0.48802915\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7935964"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4498,"cells":{"query":{"kind":"string","value":"Get the names of strands that are found in this twine."},"document":{"kind":"string","value":"def available_strands(self):\n return self._available_strands"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def iter_strands(self):\n return iter(self.strand_list)","def getStationsName(self) :\n names = []\n for sts in self._stations :\n names.append(sts.getName())\n\n return names","def get_well_aliases(self):\n return self.info_wells['well'].unique()","def list_available_strains(self):\n return [strain for strain in self.sample_dict]","def find_hypernyms(self, syns):\n names = set()\n # Find hypernyms of each syn\n for syn in syns:\n hypernyms = syn.hypernyms()\n # find hypernyms one more level up\n for hypernym in hypernyms:\n names.add(hypernym.name())\n hypernyms_second = hypernym.hypernyms()\n for h in hypernyms_second:\n names.add(h.name())\n return names","def wells_list(self, wtype='all'):\n list_names = []\n for well_data in self.wells:\n if wtype == 'all':\n list_names.append(well_data.drawdown.name)\n elif wtype == well_data._type - 2:\n list_names.append(well_data.drawdown.name)\n return(list_names)","def names(self) -> list[str]:","def stl_names(self):\n return [stl.member.get_full_name() for stl in self.stls.all()]","def _getAllWorklistNames(self):\n log.debug(\"Finding all worklists mentioned in this statemachine.\")\n worklists = {}\n names = [s.getTaggedValue('worklist')\n for s in self.sm.getStates(no_duplicates = 1)\n if s.getTaggedValue('worklist')]\n for name in names:\n worklists[name] = 'just filtering out doubles'\n result = worklists.keys()\n log.debug(\"Found the following worklists: %r.\", result)\n return result","def synonyms(self):\n\n return [synonym[\"name\"] for synonym in self._get_synonym_json()]","def furanose_names(self):\n output = set()\n for item in self.monomers():\n if item in self.furanose_fac:\n output.add(self.furanose_fac[item][\"name\"])\n return list(output)","def getNames(self) -> List[unicode]:\n ...","def speciesNames(self):\n nsp = self.nSpecies()\n return map(self.speciesName,range(nsp))","def get_station_names(self):\n station_names = []\n for wrapper in self.soup.find_all(\"div\", {\"class\": \"stop-wrapper\"}):\n station_name = ' '.join(wrapper.find(\"h3\").text.split(' ')[:-1])\n station_names.append(station_name)\n return np.array(station_names).T","def names(self) -> PlaceNames | None:\n pass","def get_names(self):\n return self.names","def get_words_from_sysets(synset):\n synlist = []\n for s in synset:\n syns = s.lemmas()[0].name()\n synlist.append(syns)\n return synlist","def get_holonyms(synset):\n return set(\n synset.member_holonyms() + synset.substance_holonyms() + synset.part_holonyms()\n )","def names(self):\n\n allnames = []\n for term in self.terms:\n allnames += term.names()\n return allnames","def names(self):\n\n allnames = []\n for term in self.terms:\n allnames += term.names()\n return allnames","def tank_name_list(self):\n return list(self._node_reg.tank_names)","def names(cls) -> List[str]:","def names(self) -> List:\n ...","def synonyms(self) -> List[str]:\n return self._synonyms","def synonyms(self) -> List[str]:\n return pulumi.get(self, \"synonyms\")","def return_names(self):\n return self.__name_list","def monomer_names(self):\n output = set()\n for item in self.monomers():\n if item in self.pyranose_fac:\n output.add(self.pyranose_fac[item][\"name\"])\n return list(output)","def available_manifest_strands(self):\n return self._available_manifest_strands","def namelist(self):\n return set(self.names())","def wt_strains(df):\n \n ts_plates = []\n dma_plates = []\n for plate in df.Plate.unique():\n if ('_26C_' in plate) or ('_37C_' in plate):\n ts_plates.append(plate)\n else:\n dma_plates.append(plate)\n\n wt_strain_ids_dma = df[(df['ORF'].isin(['YOR202W'])) &\n (df['Plate'].isin(dma_plates))]['Strain ID'].unique()\n wt_strain_ids_ts = df[(df['ORF'].isin(['YOR202W', 'YMR271C'])) &\n (df['Plate'].isin(ts_plates))]['Strain ID'].unique()\n wt_strain_ids = np.append(wt_strain_ids_ts, wt_strain_ids_dma)\n \n return wt_strain_ids","def get_short_names(self) -> List[str]:\n result = []\n for elements in self._get_results_list():\n result.append(elements[0])\n return result","def pyranose_names(self):\n output = set()\n for item in self.pyranoses():\n if item in self.pyranose_fac:\n output.add(self.pyranose_fac[item][\"name\"])\n return list(output)","def species(self):\n return self.name","def list_building_names(self):\n return self.building_names","def get_names_short(self):\r\n return [p.get_name() for p in self.people]","def names(self):\n return [da.name for da in self]","def availableSquares(self):\n List2=[]\n for item in self.all:\n if item.retrieve()==\"\":\n List2.append(item.name())\n return List2","def get_names(self):\n return self.__names","def names(self) -> Sequence[str]:\n return pulumi.get(self, \"names\")","def names(self) -> Sequence[str]:\n return pulumi.get(self, \"names\")","def get_strains(names, q_dof):\n strain_functions = []\n for n, this_dof in zip(names, q_dof):\n check_qdof(n, this_dof)\n if n == 'linear_helix':\n strain_functions.append(linear_helix_strain)\n elif n == 'pure_helix':\n strain_functions.append(pure_helix_strain)\n elif n == 'torsion_helix':\n strain_functions.append(torsion_helix_strain)\n elif n == 'torsion_linear_helix':\n strain_functions.append(torsion_linear_helix_strain)\n elif n == 'quadratic':\n strain_functions.append(quadratic_strain)\n elif n == 'linear':\n strain_functions.append(linear_strain)\n elif n == 'constant':\n strain_functions.append(constant_strain)\n elif n == 'full':\n strain_functions.append(full_strain)\n else:\n print(f'{n} is not a defined strain base.')\n return strain_functions","def names(self):\n return self._names","def names(self):\n return self._names","def names(self):\n return self._names","def sons(self):\n\n return self._sons","def names(self):\n\t\treturn","def getNames(self):\n return self._Names","def get_chebi_synonyms(chebi_ent):\n if hasattr(chebi_ent, 'Synonyms'):\n return [entry.data for entry in chebi_ent.Synonyms]\n else:\n return []","def get_search_tag_names(self):\n return self._ruleset.keys()","def get_search_results(self):\n return self.get_list_of_names(self.SEARCH_RESULTS)","def termnames(self):\n\n names = []\n for term in self.terms:\n names += [term.termname]\n return names","def termnames(self):\n\n names = []\n for term in self.terms:\n names += [term.termname]\n return names","def names(self):\n return self.__names","def senses(self):\n sense_set = wordnet.synsets(self.text)\n\n result = list()\n for s in sense_set:\n result.append(s.lemma_names())\n\n return result","def name(self):\n return [o.name for o in self.obs]","def get_names(self):\n return [doc['name'] for doc in self.vocab]","def names(\n self\n ) -> Tuple[str, ...]:\n return self._names","def getRegisterNames(self):\n pass","def get_names(self):\n return sorted(list(self.df[[Data.SDATA_NAME]].drop_duplicates().iloc[:, 0]))","def fqns(self):\n return [fqn for fqn in self.runinfos]","def nameList(self):\r\n return [self.name.lower(), self.code] + self._otherNames","def getSamplesList(self):\n return self.sample_names","def species(self):\n return [node.species for node in self]","def train_stations(self) -> List[str]:\n return sorted([train_info['HE'] for train_info in train_api.stations_info.values()])","def tank_names(self):\n return self._tanks","def names():\n pass","def watershedlist():\n opts = watersheds_db()\n return [(opts[opt]['name'] + ' (' + opts[opt]['delineation'] + ')', opt) for opt in opts]","def names(cls):\n return cls.__by_name.keys()","def _find_names(place):\n tags = place['tags']\n tags_names = ['name', 'place_name', 'alt_name']\n names = []\n for tag in tags_names:\n try:\n names.extend(tags[tag].split(';'))\n except KeyError:\n pass\n if not names:\n print \"Place has no name (#{})\".format(place['id'])\n return names","def namelist(self):\n return self._handle.getnames()","def namelist(self):\n return self._handle.getnames()","def logicalnames(self):\n return self.__logicalnames.keys()","def get_words(self):\r\n\r\n #using database\r\n\r\n if self.using_database:\r\n value_tuple = (notebookname,)\r\n db_cursor.execute(\"SELECT word\"\r\n +\" FROM word_to_indexes\"\r\n +\" WHERE notebook=?;\",\r\n value_tuple)\r\n fetched = db_cursor.fetchall()\r\n if fetched:\r\n return {word[0] for word in fetched}\r\n\r\n return set()\r\n\r\n #using shelf\r\n\r\n return self.word_dict.keys()","def get_afferents_names(self):\n\t\treturn self._afferentsNames","def _getWorklistStateNames(self, worklistname):\n results = [s.getName()\n for s in self.sm.getStates(no_duplicates = 1)\n if s.getTaggedValue('worklist') == worklistname]\n log.debug(\"Associated with worklist '%s' are the \"\n \"following states: %r.\", worklistname, results)\n return results","def names(self):\r\n return resource.Name(self)","def _get_wells(self):\n wells = []\n for well in self.plate_meta['wells']:\n wells.append(well['path'])\n self.wells = wells","def getStations(self) :\n return self._stations","def getOthNames( self ):\n\n if self.othNames:\n return self.othNames.keys()\n \n nSets = self.adb.get( \"nOths\" )\n for id1 in range( nSets ):\n name = self.adb.get( \"othName\", id1 )\n self.othNames[ name ] = id1\n\n return self.othNames.keys()","def names(filter=None):","def findBrains():\r\n keys = livingDead.Frankenstein.genKeys()\r\n return keys","def get_standard_names(self):\n return [s for (i, s) in list(self._I2SMAP.items())\n if (i != self._CUSTOM) and s.strip()]","def search_brands_by_name(mystr):\n \n return Brand.query.filter(Brand.name.like('%' + mystr + '%')).all()","def names(self):\n return self.dark_name, self.light_name","def outputStateNames(self):\n names = []\n for item in self.mechanisms:\n for output_state in item.outputStates:\n names.append(output_state)\n return names","def names(self):\n if type(self.name) is types.StringType:\n return [self.name]\n else:\n return list(self.name)","def ligands(self, species=None):\n\n ligands = []\n for interaction in self.interactions(species=species):\n ligand = interaction.ligand()\n if ligand not in ligands:\n ligands.append(ligand)\n return ligands","def getOqiNames( self ):\n\n if self.oqiNames:\n return self.oqiNames.keys()\n\n n = self.adb.get( \"nSrss\" )\n for indx in xrange( n ):\n name = self.adb.get( \"srsName\", indx )\n self.oqiNames[ name ] = indx\n\n return self.oqiNames.keys()","def names(self):\n return list(item.name for item in self.mechanisms)","def obs_names(self):\n return self._obs_names","def _lookup_bands(platform, wavelengths):\r\n wave_bands = {\r\n Platform.Landsat5: {\r\n \"blue\": \"1\",\r\n \"green\": \"2\",\r\n \"red\": \"3\",\r\n \"nir\": \"4\",\r\n \"swir1\": \"5\",\r\n \"tirs\": \"6\",\r\n \"swir2\": \"7\",\r\n },\r\n Platform.Landsat7: {\r\n \"blue\": \"1\",\r\n \"green\": \"2\",\r\n \"red\": \"3\",\r\n \"nir\": \"4\",\r\n \"swir1\": \"5\",\r\n \"tirs1\": \"6_VCID_1\",\r\n \"tirs2\": \"6_VCID_2\",\r\n \"swir2\": \"7\",\r\n \"pan\": \"8\",\r\n },\r\n Platform.Landsat8: {\r\n \"aerosol\": \"1\",\r\n \"blue\": \"2\",\r\n \"green\": \"3\",\r\n \"red\": \"4\",\r\n \"nir\": \"5\",\r\n \"swir1\": \"6\",\r\n \"swir2\": \"7\",\r\n \"pan\": \"8\",\r\n \"cirrus\": \"9\",\r\n \"tirs1\": \"10\",\r\n \"tirs2\": \"11\",\r\n },\r\n Platform.Sentinel2: {\r\n \"aerosol\": \"0\",\r\n \"blue\": \"1\",\r\n \"green\": \"2\",\r\n \"red\": \"3\",\r\n \"rededge1\": \"4\",\r\n \"rededge2\": \"5\",\r\n \"rededge3\": \"6\",\r\n \"nir\": \"7\",\r\n \"rededge4\": \"8\",\r\n \"watervapor\": \"9\",\r\n \"cirrus\": \"10\",\r\n \"swir1\": \"11\",\r\n \"swir2\": \"12\",\r\n },\r\n }\r\n\r\n return [wave_bands[platform][wavelength.lower()] for wavelength in wavelengths]","def stations():\n\n return station_list","def hyponym(self, sense=None):\n s = self._synset(self.text)\n\n if not s:\n return []\n\n hypo = s.hyponyms()\n\n results = list()\n for h in hypo:\n results.append(h.lemma_names())\n\n if not sense:\n return results\n\n # TODO: Exception when not an int\n return results[:sense + 1]","def getControlTowerNames(self):\n\n table = self.metadata.tables['invTypes']\n\n stmt = select(\n [table.c.typeID, table.c.typeName], \n table.c.marketGroupID == CONTROL_TOWER_MARKET_GROUP,\n ).order_by(\n table.c.typeName)\n\n return self.select(stmt)","def find_all_ORFs_both_strands(dna):\n \n # YOUR IMPLEMENTATION HERE","def reservoir_names(self):\n return self._reservoirs","def namelist(self):\n return self._handle.namelist()","def namelist(self):\n return self._handle.namelist()","def get_weathers():\n names = [\n name for name in dir(carla.WeatherParameters)\n if re.match('[A-Z].+', name)\n ]\n weathers = {x: getattr(carla.WeatherParameters, x) for x in names}\n return weathers","def get_names(self):\n\n return self.mod_suites.keys()"],"string":"[\n \"def iter_strands(self):\\n return iter(self.strand_list)\",\n \"def getStationsName(self) :\\n names = []\\n for sts in self._stations :\\n names.append(sts.getName())\\n\\n return names\",\n \"def get_well_aliases(self):\\n return self.info_wells['well'].unique()\",\n \"def list_available_strains(self):\\n return [strain for strain in self.sample_dict]\",\n \"def find_hypernyms(self, syns):\\n names = set()\\n # Find hypernyms of each syn\\n for syn in syns:\\n hypernyms = syn.hypernyms()\\n # find hypernyms one more level up\\n for hypernym in hypernyms:\\n names.add(hypernym.name())\\n hypernyms_second = hypernym.hypernyms()\\n for h in hypernyms_second:\\n names.add(h.name())\\n return names\",\n \"def wells_list(self, wtype='all'):\\n list_names = []\\n for well_data in self.wells:\\n if wtype == 'all':\\n list_names.append(well_data.drawdown.name)\\n elif wtype == well_data._type - 2:\\n list_names.append(well_data.drawdown.name)\\n return(list_names)\",\n \"def names(self) -> list[str]:\",\n \"def stl_names(self):\\n return [stl.member.get_full_name() for stl in self.stls.all()]\",\n \"def _getAllWorklistNames(self):\\n log.debug(\\\"Finding all worklists mentioned in this statemachine.\\\")\\n worklists = {}\\n names = [s.getTaggedValue('worklist')\\n for s in self.sm.getStates(no_duplicates = 1)\\n if s.getTaggedValue('worklist')]\\n for name in names:\\n worklists[name] = 'just filtering out doubles'\\n result = worklists.keys()\\n log.debug(\\\"Found the following worklists: %r.\\\", result)\\n return result\",\n \"def synonyms(self):\\n\\n return [synonym[\\\"name\\\"] for synonym in self._get_synonym_json()]\",\n \"def furanose_names(self):\\n output = set()\\n for item in self.monomers():\\n if item in self.furanose_fac:\\n output.add(self.furanose_fac[item][\\\"name\\\"])\\n return list(output)\",\n \"def getNames(self) -> List[unicode]:\\n ...\",\n \"def speciesNames(self):\\n nsp = self.nSpecies()\\n return map(self.speciesName,range(nsp))\",\n \"def get_station_names(self):\\n station_names = []\\n for wrapper in self.soup.find_all(\\\"div\\\", {\\\"class\\\": \\\"stop-wrapper\\\"}):\\n station_name = ' '.join(wrapper.find(\\\"h3\\\").text.split(' ')[:-1])\\n station_names.append(station_name)\\n return np.array(station_names).T\",\n \"def names(self) -> PlaceNames | None:\\n pass\",\n \"def get_names(self):\\n return self.names\",\n \"def get_words_from_sysets(synset):\\n synlist = []\\n for s in synset:\\n syns = s.lemmas()[0].name()\\n synlist.append(syns)\\n return synlist\",\n \"def get_holonyms(synset):\\n return set(\\n synset.member_holonyms() + synset.substance_holonyms() + synset.part_holonyms()\\n )\",\n \"def names(self):\\n\\n allnames = []\\n for term in self.terms:\\n allnames += term.names()\\n return allnames\",\n \"def names(self):\\n\\n allnames = []\\n for term in self.terms:\\n allnames += term.names()\\n return allnames\",\n \"def tank_name_list(self):\\n return list(self._node_reg.tank_names)\",\n \"def names(cls) -> List[str]:\",\n \"def names(self) -> List:\\n ...\",\n \"def synonyms(self) -> List[str]:\\n return self._synonyms\",\n \"def synonyms(self) -> List[str]:\\n return pulumi.get(self, \\\"synonyms\\\")\",\n \"def return_names(self):\\n return self.__name_list\",\n \"def monomer_names(self):\\n output = set()\\n for item in self.monomers():\\n if item in self.pyranose_fac:\\n output.add(self.pyranose_fac[item][\\\"name\\\"])\\n return list(output)\",\n \"def available_manifest_strands(self):\\n return self._available_manifest_strands\",\n \"def namelist(self):\\n return set(self.names())\",\n \"def wt_strains(df):\\n \\n ts_plates = []\\n dma_plates = []\\n for plate in df.Plate.unique():\\n if ('_26C_' in plate) or ('_37C_' in plate):\\n ts_plates.append(plate)\\n else:\\n dma_plates.append(plate)\\n\\n wt_strain_ids_dma = df[(df['ORF'].isin(['YOR202W'])) &\\n (df['Plate'].isin(dma_plates))]['Strain ID'].unique()\\n wt_strain_ids_ts = df[(df['ORF'].isin(['YOR202W', 'YMR271C'])) &\\n (df['Plate'].isin(ts_plates))]['Strain ID'].unique()\\n wt_strain_ids = np.append(wt_strain_ids_ts, wt_strain_ids_dma)\\n \\n return wt_strain_ids\",\n \"def get_short_names(self) -> List[str]:\\n result = []\\n for elements in self._get_results_list():\\n result.append(elements[0])\\n return result\",\n \"def pyranose_names(self):\\n output = set()\\n for item in self.pyranoses():\\n if item in self.pyranose_fac:\\n output.add(self.pyranose_fac[item][\\\"name\\\"])\\n return list(output)\",\n \"def species(self):\\n return self.name\",\n \"def list_building_names(self):\\n return self.building_names\",\n \"def get_names_short(self):\\r\\n return [p.get_name() for p in self.people]\",\n \"def names(self):\\n return [da.name for da in self]\",\n \"def availableSquares(self):\\n List2=[]\\n for item in self.all:\\n if item.retrieve()==\\\"\\\":\\n List2.append(item.name())\\n return List2\",\n \"def get_names(self):\\n return self.__names\",\n \"def names(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"names\\\")\",\n \"def names(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"names\\\")\",\n \"def get_strains(names, q_dof):\\n strain_functions = []\\n for n, this_dof in zip(names, q_dof):\\n check_qdof(n, this_dof)\\n if n == 'linear_helix':\\n strain_functions.append(linear_helix_strain)\\n elif n == 'pure_helix':\\n strain_functions.append(pure_helix_strain)\\n elif n == 'torsion_helix':\\n strain_functions.append(torsion_helix_strain)\\n elif n == 'torsion_linear_helix':\\n strain_functions.append(torsion_linear_helix_strain)\\n elif n == 'quadratic':\\n strain_functions.append(quadratic_strain)\\n elif n == 'linear':\\n strain_functions.append(linear_strain)\\n elif n == 'constant':\\n strain_functions.append(constant_strain)\\n elif n == 'full':\\n strain_functions.append(full_strain)\\n else:\\n print(f'{n} is not a defined strain base.')\\n return strain_functions\",\n \"def names(self):\\n return self._names\",\n \"def names(self):\\n return self._names\",\n \"def names(self):\\n return self._names\",\n \"def sons(self):\\n\\n return self._sons\",\n \"def names(self):\\n\\t\\treturn\",\n \"def getNames(self):\\n return self._Names\",\n \"def get_chebi_synonyms(chebi_ent):\\n if hasattr(chebi_ent, 'Synonyms'):\\n return [entry.data for entry in chebi_ent.Synonyms]\\n else:\\n return []\",\n \"def get_search_tag_names(self):\\n return self._ruleset.keys()\",\n \"def get_search_results(self):\\n return self.get_list_of_names(self.SEARCH_RESULTS)\",\n \"def termnames(self):\\n\\n names = []\\n for term in self.terms:\\n names += [term.termname]\\n return names\",\n \"def termnames(self):\\n\\n names = []\\n for term in self.terms:\\n names += [term.termname]\\n return names\",\n \"def names(self):\\n return self.__names\",\n \"def senses(self):\\n sense_set = wordnet.synsets(self.text)\\n\\n result = list()\\n for s in sense_set:\\n result.append(s.lemma_names())\\n\\n return result\",\n \"def name(self):\\n return [o.name for o in self.obs]\",\n \"def get_names(self):\\n return [doc['name'] for doc in self.vocab]\",\n \"def names(\\n self\\n ) -> Tuple[str, ...]:\\n return self._names\",\n \"def getRegisterNames(self):\\n pass\",\n \"def get_names(self):\\n return sorted(list(self.df[[Data.SDATA_NAME]].drop_duplicates().iloc[:, 0]))\",\n \"def fqns(self):\\n return [fqn for fqn in self.runinfos]\",\n \"def nameList(self):\\r\\n return [self.name.lower(), self.code] + self._otherNames\",\n \"def getSamplesList(self):\\n return self.sample_names\",\n \"def species(self):\\n return [node.species for node in self]\",\n \"def train_stations(self) -> List[str]:\\n return sorted([train_info['HE'] for train_info in train_api.stations_info.values()])\",\n \"def tank_names(self):\\n return self._tanks\",\n \"def names():\\n pass\",\n \"def watershedlist():\\n opts = watersheds_db()\\n return [(opts[opt]['name'] + ' (' + opts[opt]['delineation'] + ')', opt) for opt in opts]\",\n \"def names(cls):\\n return cls.__by_name.keys()\",\n \"def _find_names(place):\\n tags = place['tags']\\n tags_names = ['name', 'place_name', 'alt_name']\\n names = []\\n for tag in tags_names:\\n try:\\n names.extend(tags[tag].split(';'))\\n except KeyError:\\n pass\\n if not names:\\n print \\\"Place has no name (#{})\\\".format(place['id'])\\n return names\",\n \"def namelist(self):\\n return self._handle.getnames()\",\n \"def namelist(self):\\n return self._handle.getnames()\",\n \"def logicalnames(self):\\n return self.__logicalnames.keys()\",\n \"def get_words(self):\\r\\n\\r\\n #using database\\r\\n\\r\\n if self.using_database:\\r\\n value_tuple = (notebookname,)\\r\\n db_cursor.execute(\\\"SELECT word\\\"\\r\\n +\\\" FROM word_to_indexes\\\"\\r\\n +\\\" WHERE notebook=?;\\\",\\r\\n value_tuple)\\r\\n fetched = db_cursor.fetchall()\\r\\n if fetched:\\r\\n return {word[0] for word in fetched}\\r\\n\\r\\n return set()\\r\\n\\r\\n #using shelf\\r\\n\\r\\n return self.word_dict.keys()\",\n \"def get_afferents_names(self):\\n\\t\\treturn self._afferentsNames\",\n \"def _getWorklistStateNames(self, worklistname):\\n results = [s.getName()\\n for s in self.sm.getStates(no_duplicates = 1)\\n if s.getTaggedValue('worklist') == worklistname]\\n log.debug(\\\"Associated with worklist '%s' are the \\\"\\n \\\"following states: %r.\\\", worklistname, results)\\n return results\",\n \"def names(self):\\r\\n return resource.Name(self)\",\n \"def _get_wells(self):\\n wells = []\\n for well in self.plate_meta['wells']:\\n wells.append(well['path'])\\n self.wells = wells\",\n \"def getStations(self) :\\n return self._stations\",\n \"def getOthNames( self ):\\n\\n if self.othNames:\\n return self.othNames.keys()\\n \\n nSets = self.adb.get( \\\"nOths\\\" )\\n for id1 in range( nSets ):\\n name = self.adb.get( \\\"othName\\\", id1 )\\n self.othNames[ name ] = id1\\n\\n return self.othNames.keys()\",\n \"def names(filter=None):\",\n \"def findBrains():\\r\\n keys = livingDead.Frankenstein.genKeys()\\r\\n return keys\",\n \"def get_standard_names(self):\\n return [s for (i, s) in list(self._I2SMAP.items())\\n if (i != self._CUSTOM) and s.strip()]\",\n \"def search_brands_by_name(mystr):\\n \\n return Brand.query.filter(Brand.name.like('%' + mystr + '%')).all()\",\n \"def names(self):\\n return self.dark_name, self.light_name\",\n \"def outputStateNames(self):\\n names = []\\n for item in self.mechanisms:\\n for output_state in item.outputStates:\\n names.append(output_state)\\n return names\",\n \"def names(self):\\n if type(self.name) is types.StringType:\\n return [self.name]\\n else:\\n return list(self.name)\",\n \"def ligands(self, species=None):\\n\\n ligands = []\\n for interaction in self.interactions(species=species):\\n ligand = interaction.ligand()\\n if ligand not in ligands:\\n ligands.append(ligand)\\n return ligands\",\n \"def getOqiNames( self ):\\n\\n if self.oqiNames:\\n return self.oqiNames.keys()\\n\\n n = self.adb.get( \\\"nSrss\\\" )\\n for indx in xrange( n ):\\n name = self.adb.get( \\\"srsName\\\", indx )\\n self.oqiNames[ name ] = indx\\n\\n return self.oqiNames.keys()\",\n \"def names(self):\\n return list(item.name for item in self.mechanisms)\",\n \"def obs_names(self):\\n return self._obs_names\",\n \"def _lookup_bands(platform, wavelengths):\\r\\n wave_bands = {\\r\\n Platform.Landsat5: {\\r\\n \\\"blue\\\": \\\"1\\\",\\r\\n \\\"green\\\": \\\"2\\\",\\r\\n \\\"red\\\": \\\"3\\\",\\r\\n \\\"nir\\\": \\\"4\\\",\\r\\n \\\"swir1\\\": \\\"5\\\",\\r\\n \\\"tirs\\\": \\\"6\\\",\\r\\n \\\"swir2\\\": \\\"7\\\",\\r\\n },\\r\\n Platform.Landsat7: {\\r\\n \\\"blue\\\": \\\"1\\\",\\r\\n \\\"green\\\": \\\"2\\\",\\r\\n \\\"red\\\": \\\"3\\\",\\r\\n \\\"nir\\\": \\\"4\\\",\\r\\n \\\"swir1\\\": \\\"5\\\",\\r\\n \\\"tirs1\\\": \\\"6_VCID_1\\\",\\r\\n \\\"tirs2\\\": \\\"6_VCID_2\\\",\\r\\n \\\"swir2\\\": \\\"7\\\",\\r\\n \\\"pan\\\": \\\"8\\\",\\r\\n },\\r\\n Platform.Landsat8: {\\r\\n \\\"aerosol\\\": \\\"1\\\",\\r\\n \\\"blue\\\": \\\"2\\\",\\r\\n \\\"green\\\": \\\"3\\\",\\r\\n \\\"red\\\": \\\"4\\\",\\r\\n \\\"nir\\\": \\\"5\\\",\\r\\n \\\"swir1\\\": \\\"6\\\",\\r\\n \\\"swir2\\\": \\\"7\\\",\\r\\n \\\"pan\\\": \\\"8\\\",\\r\\n \\\"cirrus\\\": \\\"9\\\",\\r\\n \\\"tirs1\\\": \\\"10\\\",\\r\\n \\\"tirs2\\\": \\\"11\\\",\\r\\n },\\r\\n Platform.Sentinel2: {\\r\\n \\\"aerosol\\\": \\\"0\\\",\\r\\n \\\"blue\\\": \\\"1\\\",\\r\\n \\\"green\\\": \\\"2\\\",\\r\\n \\\"red\\\": \\\"3\\\",\\r\\n \\\"rededge1\\\": \\\"4\\\",\\r\\n \\\"rededge2\\\": \\\"5\\\",\\r\\n \\\"rededge3\\\": \\\"6\\\",\\r\\n \\\"nir\\\": \\\"7\\\",\\r\\n \\\"rededge4\\\": \\\"8\\\",\\r\\n \\\"watervapor\\\": \\\"9\\\",\\r\\n \\\"cirrus\\\": \\\"10\\\",\\r\\n \\\"swir1\\\": \\\"11\\\",\\r\\n \\\"swir2\\\": \\\"12\\\",\\r\\n },\\r\\n }\\r\\n\\r\\n return [wave_bands[platform][wavelength.lower()] for wavelength in wavelengths]\",\n \"def stations():\\n\\n return station_list\",\n \"def hyponym(self, sense=None):\\n s = self._synset(self.text)\\n\\n if not s:\\n return []\\n\\n hypo = s.hyponyms()\\n\\n results = list()\\n for h in hypo:\\n results.append(h.lemma_names())\\n\\n if not sense:\\n return results\\n\\n # TODO: Exception when not an int\\n return results[:sense + 1]\",\n \"def getControlTowerNames(self):\\n\\n table = self.metadata.tables['invTypes']\\n\\n stmt = select(\\n [table.c.typeID, table.c.typeName], \\n table.c.marketGroupID == CONTROL_TOWER_MARKET_GROUP,\\n ).order_by(\\n table.c.typeName)\\n\\n return self.select(stmt)\",\n \"def find_all_ORFs_both_strands(dna):\\n \\n # YOUR IMPLEMENTATION HERE\",\n \"def reservoir_names(self):\\n return self._reservoirs\",\n \"def namelist(self):\\n return self._handle.namelist()\",\n \"def namelist(self):\\n return self._handle.namelist()\",\n \"def get_weathers():\\n names = [\\n name for name in dir(carla.WeatherParameters)\\n if re.match('[A-Z].+', name)\\n ]\\n weathers = {x: getattr(carla.WeatherParameters, x) for x in names}\\n return weathers\",\n \"def get_names(self):\\n\\n return self.mod_suites.keys()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6584263","0.65621185","0.63851863","0.62019277","0.61951375","0.60891676","0.60425985","0.6007916","0.59496164","0.59036535","0.5884974","0.58607626","0.57966846","0.57783294","0.5773814","0.5770074","0.57655287","0.5721144","0.5684944","0.5684944","0.5680266","0.56731397","0.565833","0.5656931","0.5639807","0.5628358","0.5610615","0.5599485","0.5598051","0.5592574","0.55816174","0.55744606","0.5561899","0.55568933","0.5552316","0.55410725","0.5533148","0.5518508","0.55063796","0.55063796","0.5489818","0.5478198","0.5478198","0.5478198","0.5469389","0.5453498","0.53958565","0.5395759","0.53941816","0.5388838","0.5386587","0.5386587","0.5386012","0.5381485","0.53766817","0.5371399","0.5352772","0.5347049","0.53447205","0.5344479","0.53146034","0.5310374","0.5307961","0.53049284","0.5304021","0.52941394","0.5290515","0.52808475","0.52768147","0.52710783","0.52710783","0.5269443","0.52683145","0.5267394","0.52660096","0.5265372","0.52586836","0.5250815","0.52506655","0.5247058","0.52468354","0.52247256","0.5215784","0.520869","0.5206171","0.5202638","0.5200922","0.5200802","0.51960826","0.51917684","0.51904","0.51898015","0.5185919","0.5185543","0.51833427","0.517914","0.5177792","0.5177792","0.5177746","0.5177566"],"string":"[\n \"0.6584263\",\n \"0.65621185\",\n \"0.63851863\",\n \"0.62019277\",\n \"0.61951375\",\n \"0.60891676\",\n \"0.60425985\",\n \"0.6007916\",\n \"0.59496164\",\n \"0.59036535\",\n \"0.5884974\",\n \"0.58607626\",\n \"0.57966846\",\n \"0.57783294\",\n \"0.5773814\",\n \"0.5770074\",\n \"0.57655287\",\n \"0.5721144\",\n \"0.5684944\",\n \"0.5684944\",\n \"0.5680266\",\n \"0.56731397\",\n \"0.565833\",\n \"0.5656931\",\n \"0.5639807\",\n \"0.5628358\",\n \"0.5610615\",\n \"0.5599485\",\n \"0.5598051\",\n \"0.5592574\",\n \"0.55816174\",\n \"0.55744606\",\n \"0.5561899\",\n \"0.55568933\",\n \"0.5552316\",\n \"0.55410725\",\n \"0.5533148\",\n \"0.5518508\",\n \"0.55063796\",\n \"0.55063796\",\n \"0.5489818\",\n \"0.5478198\",\n \"0.5478198\",\n \"0.5478198\",\n \"0.5469389\",\n \"0.5453498\",\n \"0.53958565\",\n \"0.5395759\",\n \"0.53941816\",\n \"0.5388838\",\n \"0.5386587\",\n \"0.5386587\",\n \"0.5386012\",\n \"0.5381485\",\n \"0.53766817\",\n \"0.5371399\",\n \"0.5352772\",\n \"0.5347049\",\n \"0.53447205\",\n \"0.5344479\",\n \"0.53146034\",\n \"0.5310374\",\n \"0.5307961\",\n \"0.53049284\",\n \"0.5304021\",\n \"0.52941394\",\n \"0.5290515\",\n \"0.52808475\",\n \"0.52768147\",\n \"0.52710783\",\n \"0.52710783\",\n \"0.5269443\",\n \"0.52683145\",\n \"0.5267394\",\n \"0.52660096\",\n \"0.5265372\",\n \"0.52586836\",\n \"0.5250815\",\n \"0.52506655\",\n \"0.5247058\",\n \"0.52468354\",\n \"0.52247256\",\n \"0.5215784\",\n \"0.520869\",\n \"0.5206171\",\n \"0.5202638\",\n \"0.5200922\",\n \"0.5200802\",\n \"0.51960826\",\n \"0.51917684\",\n \"0.51904\",\n \"0.51898015\",\n \"0.5185919\",\n \"0.5185543\",\n \"0.51833427\",\n \"0.517914\",\n \"0.5177792\",\n \"0.5177792\",\n \"0.5177746\",\n \"0.5177566\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71010107"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4499,"cells":{"query":{"kind":"string","value":"Get the names of the manifest strands that are found in this twine."},"document":{"kind":"string","value":"def available_manifest_strands(self):\n return self._available_manifest_strands"},"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 available_strands(self):\n return self._available_strands","def list_manifests():\n import enaml\n with enaml.imports():\n from .pulses.manifest import PulsesManagerManifest\n from .tasks.manifest import PulsesTasksManifest\n from .measure.manifest import PulsesMeasureManifest\n return [PulsesManagerManifest, PulsesTasksManifest, PulsesMeasureManifest]","def getAtomNames(self):\n return self._raw_data['ATOM_NAME']","def names(self) -> List[str]:\n names = set()\n for summary_dir in self._summary_dirs:\n for subdir in summary_dir.glob(\"*\"):\n if subdir == _METADATA:\n continue\n if subdir.is_dir():\n names.add(subdir.name)\n return sorted(names)","def names(self) -> list[str]:","def get_well_aliases(self):\n return self.info_wells['well'].unique()","def installed_appnames():\n appnames = set()\n for finder in sys.meta_path:\n if hasattr(finder, 'appname'):\n appnames.add(finder.appname)\n return appnames","def fqns(self):\n return [fqn for fqn in self.runinfos]","def GetResourceNames(self):\r\n return [x.name for x in self.resources]","def synonyms(self):\n\n return [synonym[\"name\"] for synonym in self._get_synonym_json()]","def all_registered_appnames():\n yield from sorted(Registry.monomers.keys())","def get_all_fullpaths(self):\n files = []\n for mf in self.manifests:\n files.extend(self.manifests[mf].get_fullpaths())\n return files","def onboot_names(self):\n ext_names = []\n for ext in self.extensions.values():\n if not ext.onboot:\n continue\n ext_names.append(ext.name)\n return ', '.join(sorted(ext_names))","def app_names(self):\n return self.get_app_names()","def get_app_names(self):\n groups = self['__store']\n lookup = {\n g.group_id: g.name[2:]\n for g in groups\n if (g.name.startswith('a_'))\n }\n return set(map(lookup.get, self.get_app_ids()))","def get_app_manifests(self,sfilter = None):\n if sfilter:\n try:\n return filter(lambda app: app[\"developer\"] == sfilter[\"developer\"] and\n app[\"name\"] == sfilter[\"name\"] and\n app[\"version\"] == sfilter[\"version\"], self.app_manifests)\n except:\n return []\n else :\n return self.app_manifests","def RAppNames(self):\n\t\tnames=[]\n\t\tfor item in range(self.rApps.Count):\n\t\t\tnames.append(self.rApps.Item(item).Name)\n\t\treturn names","def namelist(self):\n return self._handle.getnames()","def namelist(self):\n return self._handle.getnames()","def names() -> Tuple[str, ...]:\n return plugins.list_all(package_name=__name__)","def find_hypernyms(self, syns):\n names = set()\n # Find hypernyms of each syn\n for syn in syns:\n hypernyms = syn.hypernyms()\n # find hypernyms one more level up\n for hypernym in hypernyms:\n names.add(hypernym.name())\n hypernyms_second = hypernym.hypernyms()\n for h in hypernyms_second:\n names.add(h.name())\n return names","def monomer_names(self):\n output = set()\n for item in self.monomers():\n if item in self.pyranose_fac:\n output.add(self.pyranose_fac[item][\"name\"])\n return list(output)","def namelist(self):\n return self._handle.namelist()","def namelist(self):\n return self._handle.namelist()","def mapped_names(self):\n return [x.distro for x in DistroMapping.distros_mapped_to(self.name, self.version)]","def get_afferents_names(self):\n\t\treturn self._afferentsNames","def names(self):\r\n return resource.Name(self)","def names(self):\n return list(item.name for item in self.mechanisms)","def getStationsName(self) :\n names = []\n for sts in self._stations :\n names.append(sts.getName())\n\n return names","def get_short_names(self) -> List[str]:\n result = []\n for elements in self._get_results_list():\n result.append(elements[0])\n return result","def resource_names(self):\n return self._resource_names","def get_namespaces():\n return list(StaticAsset._load_namespaces().keys())","def names(self):\n if not self.extensions:\n self.discover()\n\n names = list(self.builtins.keys())\n names += self.extensions.keys()\n\n return sorted(names)","def names(cls) -> List[str]:","def getNames(self) -> List[unicode]:\n ...","def applications(self):\n return [self.app] + self.mounts.values()","def GetScaffolderNames(cls) -> Iterator[str]:\n for scaffolder_name, _ in cls.GetScaffolders():\n yield scaffolder_name","def names(self) -> List:\n ...","def synonyms(self) -> List[str]:\n return self._synonyms","def names(self):\n\t\treturn","def namelist(self):\n return set(self.names())","def get_setup_names(self):\n self.setup_names = list(self._optimetrics.GetSetupNames())\n return self.setup_names.copy()","def getRegisterNames(self):\n pass","def getOutputNames(self):\n return self.dirs","def get_names(self):\n return self.names","def synonyms(self) -> List[str]:\n return pulumi.get(self, \"synonyms\")","def monomers(self):\n return sorted(set([self[x.split(\"_\")[-1]][\"name\"] for x in self.keys]), key=lambda x: -len(x))","def all_present_subsystems(self):\n return _yield_subdir_names(self.subsys_configs)","def get_all_setups_roots():\n ta_roots = cmds.ls(\"*.{}\".format(CONFIG[\"config_attr\"]), r=True, o=True)\n return ta_roots","def names(self):\n return self._names","def names(self):\n return self._names","def names(self):\n return self._names","def pump_name_list(self):\n return list(self._link_reg.pump_names)","def furanose_names(self):\n output = set()\n for item in self.monomers():\n if item in self.furanose_fac:\n output.add(self.furanose_fac[item][\"name\"])\n return list(output)","def get_allref(self):\n return self.__applicationList.keys()","def masters(self):\n return sorted(self.get_ns_name(ns) for ns in self.profile.masters.all())","def full_names(self) -> List[str]:\n self.names = [\n \".\".join(prod)\n for prod in product(*self._namespaces, self.terminals)\n ]\n return self.names","def get_names(self):\n\n return self.mod_suites.keys()","def _get_all_saves_names(wit_path):\n names = []\n for item in os.listdir(os.path.join(wit_path, '.wit', 'images')):\n path = os.path.join(wit_path, '.wit', 'images', item)\n if os.path.isdir(path):\n names.append(item)\n return names","def _getAllWorklistNames(self):\n log.debug(\"Finding all worklists mentioned in this statemachine.\")\n worklists = {}\n names = [s.getTaggedValue('worklist')\n for s in self.sm.getStates(no_duplicates = 1)\n if s.getTaggedValue('worklist')]\n for name in names:\n worklists[name] = 'just filtering out doubles'\n result = worklists.keys()\n log.debug(\"Found the following worklists: %r.\", result)\n return result","def getLocalPluginNames():\r\n return [os.path.basename(f) for f in glob(buildPath('*.dll'))]","def names(self):\n return self.__names","def getAllXsSuffixes(self):\n return sorted(set(b.getMicroSuffix() for b in self.getBlocks()))","def list_minerals():\n return _list_tindyb_unique_values(\"name\", dbpath=__dbpath__)","def get_names(self):\n return self.__names","def names(self) -> Sequence[str]:\n return pulumi.get(self, \"names\")","def names(self) -> Sequence[str]:\n return pulumi.get(self, \"names\")","def names(self):\n return [da.name for da in self]","def resource_names(self) -> pulumi.Output[Optional[Mapping[str, Sequence[str]]]]:\n return pulumi.get(self, \"resource_names\")","def list_building_names(self):\n return self.building_names","def get_manifest(self):\n return self.manifest","def names_for(self, name):\n names = [\"%s.%s\" % (self.package, name)]\n if self.prefix:\n names.append(\"%s.%s\" % (self.prefix, names[0]))\n return names","def get_manifest_extensions_mapping(self):\n return {\"stitching-element\":\n \"http://example.com/stitching-element\"} # /manifest.xsd","def get_available_data_asset_names(self) -> List[str]:\n raise NotImplementedError","def get_chebi_synonyms(chebi_ent):\n if hasattr(chebi_ent, 'Synonyms'):\n return [entry.data for entry in chebi_ent.Synonyms]\n else:\n return []","def nombresHojas(libro):\r\n return [sh.name for sh in libro.sheets()]","def return_names(self):\n return self.__name_list","def head_pump_name_list(self):\n return list(self._link_reg.head_pump_names)","def name(self):\n\n return self.manifest[\"name\"]","def names(self):\n return [x for x in self._dict.keys()]","def names(self):\n\n allnames = []\n for term in self.terms:\n allnames += term.names()\n return allnames","def names(self):\n\n allnames = []\n for term in self.terms:\n allnames += term.names()\n return allnames","def resource_names(self) -> Optional[Sequence[str]]:\n return pulumi.get(self, \"resource_names\")","def resource_names(self) -> Optional[Sequence[str]]:\n return pulumi.get(self, \"resource_names\")","def list_builders(self) -> List[str]:\n return sorted(_iter_builder_names(self._ns2data_dir))","def getModuleNames():\n import setup\n names = [e.name[1:] for e in setup.wxpExtensions]\n return names","def namelist(self):\n return []","def get_dashboard_names(cls):\n dashboards = cls._get_all_dashboards()\n return [str(dboard[\"filename\"]) for dboard in dashboards]","def stl_names(self):\n return [stl.member.get_full_name() for stl in self.stls.all()]","def get_names(dep):\n res = [dep.name]\n return res","def iter_strands(self):\n return iter(self.strand_list)","def list_apps(self) -> list:\n apps = self.app.list_apps()\n app_list = [app[\"title\"] for app in apps]\n return app_list","def list_available_strains(self):\n return [strain for strain in self.sample_dict]","def pyranose_names(self):\n output = set()\n for item in self.pyranoses():\n if item in self.pyranose_fac:\n output.add(self.pyranose_fac[item][\"name\"])\n return list(output)","def tank_name_list(self):\n return list(self._node_reg.tank_names)","def get_apps(self) -> List[str]:\n return list(self.config[\"apps\"].keys())","def get_startup_extensions(self):\n final_list = []\n for entry in self.bot_data_file[\"startup_extensions\"]:\n final_list.append(str(entry[\"name\"]))\n return final_list","def bsw_getAllAssetNames(astType, episode=None):\n # get basic inputs.\n basePath = ProjectNamingInputs().basePath\n projectName = ProjectNamingInputs().projectName\n assetType = ProjectNamingInputs().assetType\n projectType = ProjectNamingInputs().projectType\n if projectType == 'series':\n assetDirectory = '{basePath}/{projectName}/01_pre/{assetType}/{episode}/' \\\n .format(basePath=basePath, projectName=projectName, assetType=assetType[astType], episode=episode)\n else:\n assetDirectory = '{basePath}/{projectName}/01_pre/{assetType}/' \\\n .format(basePath=basePath, projectName=projectName, assetType=assetType[astType])\n # if asset directory is not found then return message.\n if os.path.exists(assetDirectory):\n allAstNames = [each for each in os.listdir(assetDirectory) if os.path.isdir(os.path.join(assetDirectory, each))]\n else:\n allAstNames = ['asset is not found']\n return allAstNames","def get_words_from_sysets(synset):\n synlist = []\n for s in synset:\n syns = s.lemmas()[0].name()\n synlist.append(syns)\n return synlist","def getAssemblies(pth):\n if pth.lower().endswith(\".manifest\"):\n return []\n # check for manifest file\n manifestnm = pth + \".manifest\"\n if os.path.isfile(manifestnm):\n with open(manifestnm, \"rb\") as fd:\n res = {RT_MANIFEST: {1: {0: fd.read()}}}\n else:\n # check the binary for embedded manifest\n try:\n res = GetManifestResources(pth)\n except winresource.pywintypes.error as exc:\n if exc.args[0] == winresource.ERROR_BAD_EXE_FORMAT:\n logger.info('Cannot get manifest resource from non-PE '\n 'file %s', pth)\n return []\n raise\n rv = []\n if RT_MANIFEST in res and len(res[RT_MANIFEST]):\n for name in res[RT_MANIFEST]:\n for language in res[RT_MANIFEST][name]:\n # check the manifest for dependent assemblies\n try:\n manifest = Manifest()\n manifest.filename = \":\".join([pth, str(RT_MANIFEST),\n str(name), str(language)])\n manifest.parse_string(res[RT_MANIFEST][name][language],\n False)\n except Exception as exc:\n logger.error(\"Can not parse manifest resource %s, %s\"\n \" from %s\", name, language, pth, exc_info=1)\n else:\n if manifest.dependentAssemblies:\n logger.debug(\"Dependent assemblies of %s:\", pth)\n logger.debug(\", \".join([assembly.getid()\n for assembly in\n manifest.dependentAssemblies]))\n rv.extend(manifest.dependentAssemblies)\n return rv"],"string":"[\n \"def available_strands(self):\\n return self._available_strands\",\n \"def list_manifests():\\n import enaml\\n with enaml.imports():\\n from .pulses.manifest import PulsesManagerManifest\\n from .tasks.manifest import PulsesTasksManifest\\n from .measure.manifest import PulsesMeasureManifest\\n return [PulsesManagerManifest, PulsesTasksManifest, PulsesMeasureManifest]\",\n \"def getAtomNames(self):\\n return self._raw_data['ATOM_NAME']\",\n \"def names(self) -> List[str]:\\n names = set()\\n for summary_dir in self._summary_dirs:\\n for subdir in summary_dir.glob(\\\"*\\\"):\\n if subdir == _METADATA:\\n continue\\n if subdir.is_dir():\\n names.add(subdir.name)\\n return sorted(names)\",\n \"def names(self) -> list[str]:\",\n \"def get_well_aliases(self):\\n return self.info_wells['well'].unique()\",\n \"def installed_appnames():\\n appnames = set()\\n for finder in sys.meta_path:\\n if hasattr(finder, 'appname'):\\n appnames.add(finder.appname)\\n return appnames\",\n \"def fqns(self):\\n return [fqn for fqn in self.runinfos]\",\n \"def GetResourceNames(self):\\r\\n return [x.name for x in self.resources]\",\n \"def synonyms(self):\\n\\n return [synonym[\\\"name\\\"] for synonym in self._get_synonym_json()]\",\n \"def all_registered_appnames():\\n yield from sorted(Registry.monomers.keys())\",\n \"def get_all_fullpaths(self):\\n files = []\\n for mf in self.manifests:\\n files.extend(self.manifests[mf].get_fullpaths())\\n return files\",\n \"def onboot_names(self):\\n ext_names = []\\n for ext in self.extensions.values():\\n if not ext.onboot:\\n continue\\n ext_names.append(ext.name)\\n return ', '.join(sorted(ext_names))\",\n \"def app_names(self):\\n return self.get_app_names()\",\n \"def get_app_names(self):\\n groups = self['__store']\\n lookup = {\\n g.group_id: g.name[2:]\\n for g in groups\\n if (g.name.startswith('a_'))\\n }\\n return set(map(lookup.get, self.get_app_ids()))\",\n \"def get_app_manifests(self,sfilter = None):\\n if sfilter:\\n try:\\n return filter(lambda app: app[\\\"developer\\\"] == sfilter[\\\"developer\\\"] and\\n app[\\\"name\\\"] == sfilter[\\\"name\\\"] and\\n app[\\\"version\\\"] == sfilter[\\\"version\\\"], self.app_manifests)\\n except:\\n return []\\n else :\\n return self.app_manifests\",\n \"def RAppNames(self):\\n\\t\\tnames=[]\\n\\t\\tfor item in range(self.rApps.Count):\\n\\t\\t\\tnames.append(self.rApps.Item(item).Name)\\n\\t\\treturn names\",\n \"def namelist(self):\\n return self._handle.getnames()\",\n \"def namelist(self):\\n return self._handle.getnames()\",\n \"def names() -> Tuple[str, ...]:\\n return plugins.list_all(package_name=__name__)\",\n \"def find_hypernyms(self, syns):\\n names = set()\\n # Find hypernyms of each syn\\n for syn in syns:\\n hypernyms = syn.hypernyms()\\n # find hypernyms one more level up\\n for hypernym in hypernyms:\\n names.add(hypernym.name())\\n hypernyms_second = hypernym.hypernyms()\\n for h in hypernyms_second:\\n names.add(h.name())\\n return names\",\n \"def monomer_names(self):\\n output = set()\\n for item in self.monomers():\\n if item in self.pyranose_fac:\\n output.add(self.pyranose_fac[item][\\\"name\\\"])\\n return list(output)\",\n \"def namelist(self):\\n return self._handle.namelist()\",\n \"def namelist(self):\\n return self._handle.namelist()\",\n \"def mapped_names(self):\\n return [x.distro for x in DistroMapping.distros_mapped_to(self.name, self.version)]\",\n \"def get_afferents_names(self):\\n\\t\\treturn self._afferentsNames\",\n \"def names(self):\\r\\n return resource.Name(self)\",\n \"def names(self):\\n return list(item.name for item in self.mechanisms)\",\n \"def getStationsName(self) :\\n names = []\\n for sts in self._stations :\\n names.append(sts.getName())\\n\\n return names\",\n \"def get_short_names(self) -> List[str]:\\n result = []\\n for elements in self._get_results_list():\\n result.append(elements[0])\\n return result\",\n \"def resource_names(self):\\n return self._resource_names\",\n \"def get_namespaces():\\n return list(StaticAsset._load_namespaces().keys())\",\n \"def names(self):\\n if not self.extensions:\\n self.discover()\\n\\n names = list(self.builtins.keys())\\n names += self.extensions.keys()\\n\\n return sorted(names)\",\n \"def names(cls) -> List[str]:\",\n \"def getNames(self) -> List[unicode]:\\n ...\",\n \"def applications(self):\\n return [self.app] + self.mounts.values()\",\n \"def GetScaffolderNames(cls) -> Iterator[str]:\\n for scaffolder_name, _ in cls.GetScaffolders():\\n yield scaffolder_name\",\n \"def names(self) -> List:\\n ...\",\n \"def synonyms(self) -> List[str]:\\n return self._synonyms\",\n \"def names(self):\\n\\t\\treturn\",\n \"def namelist(self):\\n return set(self.names())\",\n \"def get_setup_names(self):\\n self.setup_names = list(self._optimetrics.GetSetupNames())\\n return self.setup_names.copy()\",\n \"def getRegisterNames(self):\\n pass\",\n \"def getOutputNames(self):\\n return self.dirs\",\n \"def get_names(self):\\n return self.names\",\n \"def synonyms(self) -> List[str]:\\n return pulumi.get(self, \\\"synonyms\\\")\",\n \"def monomers(self):\\n return sorted(set([self[x.split(\\\"_\\\")[-1]][\\\"name\\\"] for x in self.keys]), key=lambda x: -len(x))\",\n \"def all_present_subsystems(self):\\n return _yield_subdir_names(self.subsys_configs)\",\n \"def get_all_setups_roots():\\n ta_roots = cmds.ls(\\\"*.{}\\\".format(CONFIG[\\\"config_attr\\\"]), r=True, o=True)\\n return ta_roots\",\n \"def names(self):\\n return self._names\",\n \"def names(self):\\n return self._names\",\n \"def names(self):\\n return self._names\",\n \"def pump_name_list(self):\\n return list(self._link_reg.pump_names)\",\n \"def furanose_names(self):\\n output = set()\\n for item in self.monomers():\\n if item in self.furanose_fac:\\n output.add(self.furanose_fac[item][\\\"name\\\"])\\n return list(output)\",\n \"def get_allref(self):\\n return self.__applicationList.keys()\",\n \"def masters(self):\\n return sorted(self.get_ns_name(ns) for ns in self.profile.masters.all())\",\n \"def full_names(self) -> List[str]:\\n self.names = [\\n \\\".\\\".join(prod)\\n for prod in product(*self._namespaces, self.terminals)\\n ]\\n return self.names\",\n \"def get_names(self):\\n\\n return self.mod_suites.keys()\",\n \"def _get_all_saves_names(wit_path):\\n names = []\\n for item in os.listdir(os.path.join(wit_path, '.wit', 'images')):\\n path = os.path.join(wit_path, '.wit', 'images', item)\\n if os.path.isdir(path):\\n names.append(item)\\n return names\",\n \"def _getAllWorklistNames(self):\\n log.debug(\\\"Finding all worklists mentioned in this statemachine.\\\")\\n worklists = {}\\n names = [s.getTaggedValue('worklist')\\n for s in self.sm.getStates(no_duplicates = 1)\\n if s.getTaggedValue('worklist')]\\n for name in names:\\n worklists[name] = 'just filtering out doubles'\\n result = worklists.keys()\\n log.debug(\\\"Found the following worklists: %r.\\\", result)\\n return result\",\n \"def getLocalPluginNames():\\r\\n return [os.path.basename(f) for f in glob(buildPath('*.dll'))]\",\n \"def names(self):\\n return self.__names\",\n \"def getAllXsSuffixes(self):\\n return sorted(set(b.getMicroSuffix() for b in self.getBlocks()))\",\n \"def list_minerals():\\n return _list_tindyb_unique_values(\\\"name\\\", dbpath=__dbpath__)\",\n \"def get_names(self):\\n return self.__names\",\n \"def names(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"names\\\")\",\n \"def names(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"names\\\")\",\n \"def names(self):\\n return [da.name for da in self]\",\n \"def resource_names(self) -> pulumi.Output[Optional[Mapping[str, Sequence[str]]]]:\\n return pulumi.get(self, \\\"resource_names\\\")\",\n \"def list_building_names(self):\\n return self.building_names\",\n \"def get_manifest(self):\\n return self.manifest\",\n \"def names_for(self, name):\\n names = [\\\"%s.%s\\\" % (self.package, name)]\\n if self.prefix:\\n names.append(\\\"%s.%s\\\" % (self.prefix, names[0]))\\n return names\",\n \"def get_manifest_extensions_mapping(self):\\n return {\\\"stitching-element\\\":\\n \\\"http://example.com/stitching-element\\\"} # /manifest.xsd\",\n \"def get_available_data_asset_names(self) -> List[str]:\\n raise NotImplementedError\",\n \"def get_chebi_synonyms(chebi_ent):\\n if hasattr(chebi_ent, 'Synonyms'):\\n return [entry.data for entry in chebi_ent.Synonyms]\\n else:\\n return []\",\n \"def nombresHojas(libro):\\r\\n return [sh.name for sh in libro.sheets()]\",\n \"def return_names(self):\\n return self.__name_list\",\n \"def head_pump_name_list(self):\\n return list(self._link_reg.head_pump_names)\",\n \"def name(self):\\n\\n return self.manifest[\\\"name\\\"]\",\n \"def names(self):\\n return [x for x in self._dict.keys()]\",\n \"def names(self):\\n\\n allnames = []\\n for term in self.terms:\\n allnames += term.names()\\n return allnames\",\n \"def names(self):\\n\\n allnames = []\\n for term in self.terms:\\n allnames += term.names()\\n return allnames\",\n \"def resource_names(self) -> Optional[Sequence[str]]:\\n return pulumi.get(self, \\\"resource_names\\\")\",\n \"def resource_names(self) -> Optional[Sequence[str]]:\\n return pulumi.get(self, \\\"resource_names\\\")\",\n \"def list_builders(self) -> List[str]:\\n return sorted(_iter_builder_names(self._ns2data_dir))\",\n \"def getModuleNames():\\n import setup\\n names = [e.name[1:] for e in setup.wxpExtensions]\\n return names\",\n \"def namelist(self):\\n return []\",\n \"def get_dashboard_names(cls):\\n dashboards = cls._get_all_dashboards()\\n return [str(dboard[\\\"filename\\\"]) for dboard in dashboards]\",\n \"def stl_names(self):\\n return [stl.member.get_full_name() for stl in self.stls.all()]\",\n \"def get_names(dep):\\n res = [dep.name]\\n return res\",\n \"def iter_strands(self):\\n return iter(self.strand_list)\",\n \"def list_apps(self) -> list:\\n apps = self.app.list_apps()\\n app_list = [app[\\\"title\\\"] for app in apps]\\n return app_list\",\n \"def list_available_strains(self):\\n return [strain for strain in self.sample_dict]\",\n \"def pyranose_names(self):\\n output = set()\\n for item in self.pyranoses():\\n if item in self.pyranose_fac:\\n output.add(self.pyranose_fac[item][\\\"name\\\"])\\n return list(output)\",\n \"def tank_name_list(self):\\n return list(self._node_reg.tank_names)\",\n \"def get_apps(self) -> List[str]:\\n return list(self.config[\\\"apps\\\"].keys())\",\n \"def get_startup_extensions(self):\\n final_list = []\\n for entry in self.bot_data_file[\\\"startup_extensions\\\"]:\\n final_list.append(str(entry[\\\"name\\\"]))\\n return final_list\",\n \"def bsw_getAllAssetNames(astType, episode=None):\\n # get basic inputs.\\n basePath = ProjectNamingInputs().basePath\\n projectName = ProjectNamingInputs().projectName\\n assetType = ProjectNamingInputs().assetType\\n projectType = ProjectNamingInputs().projectType\\n if projectType == 'series':\\n assetDirectory = '{basePath}/{projectName}/01_pre/{assetType}/{episode}/' \\\\\\n .format(basePath=basePath, projectName=projectName, assetType=assetType[astType], episode=episode)\\n else:\\n assetDirectory = '{basePath}/{projectName}/01_pre/{assetType}/' \\\\\\n .format(basePath=basePath, projectName=projectName, assetType=assetType[astType])\\n # if asset directory is not found then return message.\\n if os.path.exists(assetDirectory):\\n allAstNames = [each for each in os.listdir(assetDirectory) if os.path.isdir(os.path.join(assetDirectory, each))]\\n else:\\n allAstNames = ['asset is not found']\\n return allAstNames\",\n \"def get_words_from_sysets(synset):\\n synlist = []\\n for s in synset:\\n syns = s.lemmas()[0].name()\\n synlist.append(syns)\\n return synlist\",\n \"def getAssemblies(pth):\\n if pth.lower().endswith(\\\".manifest\\\"):\\n return []\\n # check for manifest file\\n manifestnm = pth + \\\".manifest\\\"\\n if os.path.isfile(manifestnm):\\n with open(manifestnm, \\\"rb\\\") as fd:\\n res = {RT_MANIFEST: {1: {0: fd.read()}}}\\n else:\\n # check the binary for embedded manifest\\n try:\\n res = GetManifestResources(pth)\\n except winresource.pywintypes.error as exc:\\n if exc.args[0] == winresource.ERROR_BAD_EXE_FORMAT:\\n logger.info('Cannot get manifest resource from non-PE '\\n 'file %s', pth)\\n return []\\n raise\\n rv = []\\n if RT_MANIFEST in res and len(res[RT_MANIFEST]):\\n for name in res[RT_MANIFEST]:\\n for language in res[RT_MANIFEST][name]:\\n # check the manifest for dependent assemblies\\n try:\\n manifest = Manifest()\\n manifest.filename = \\\":\\\".join([pth, str(RT_MANIFEST),\\n str(name), str(language)])\\n manifest.parse_string(res[RT_MANIFEST][name][language],\\n False)\\n except Exception as exc:\\n logger.error(\\\"Can not parse manifest resource %s, %s\\\"\\n \\\" from %s\\\", name, language, pth, exc_info=1)\\n else:\\n if manifest.dependentAssemblies:\\n logger.debug(\\\"Dependent assemblies of %s:\\\", pth)\\n logger.debug(\\\", \\\".join([assembly.getid()\\n for assembly in\\n manifest.dependentAssemblies]))\\n rv.extend(manifest.dependentAssemblies)\\n return rv\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6490598","0.61462444","0.6061251","0.6059069","0.59545153","0.59168273","0.5911148","0.5903504","0.5897712","0.5851716","0.58406675","0.5829558","0.58154243","0.5781835","0.57704556","0.57661283","0.57341903","0.56977165","0.56977165","0.56939626","0.5673895","0.56689405","0.5650809","0.5650809","0.5626021","0.5612284","0.55900735","0.5579343","0.5575883","0.55578464","0.55495936","0.5538037","0.55195975","0.5518561","0.549977","0.54934454","0.54904467","0.54861504","0.5473182","0.5470953","0.5431308","0.542964","0.54272795","0.54192716","0.5418092","0.5402415","0.54015356","0.5393227","0.53920037","0.5384717","0.5384717","0.5384717","0.5381068","0.53771704","0.5375933","0.53716","0.5370175","0.536531","0.5353076","0.5349269","0.534405","0.5336683","0.5334404","0.53322655","0.53313214","0.5314561","0.5314561","0.5307938","0.5298948","0.5283195","0.5268926","0.52688473","0.5265227","0.526392","0.52555835","0.5243347","0.5241348","0.52382857","0.52369785","0.5225406","0.52213395","0.52213395","0.52176785","0.52176785","0.5210682","0.5209672","0.5208581","0.5208516","0.52082384","0.52056503","0.5194234","0.51907253","0.5189849","0.5181321","0.5178837","0.5178417","0.5169882","0.5169874","0.51693195","0.51668674"],"string":"[\n \"0.6490598\",\n \"0.61462444\",\n \"0.6061251\",\n \"0.6059069\",\n \"0.59545153\",\n \"0.59168273\",\n \"0.5911148\",\n \"0.5903504\",\n \"0.5897712\",\n \"0.5851716\",\n \"0.58406675\",\n \"0.5829558\",\n \"0.58154243\",\n \"0.5781835\",\n \"0.57704556\",\n \"0.57661283\",\n \"0.57341903\",\n \"0.56977165\",\n \"0.56977165\",\n \"0.56939626\",\n \"0.5673895\",\n \"0.56689405\",\n \"0.5650809\",\n \"0.5650809\",\n \"0.5626021\",\n \"0.5612284\",\n \"0.55900735\",\n \"0.5579343\",\n \"0.5575883\",\n \"0.55578464\",\n \"0.55495936\",\n \"0.5538037\",\n \"0.55195975\",\n \"0.5518561\",\n \"0.549977\",\n \"0.54934454\",\n \"0.54904467\",\n \"0.54861504\",\n \"0.5473182\",\n \"0.5470953\",\n \"0.5431308\",\n \"0.542964\",\n \"0.54272795\",\n \"0.54192716\",\n \"0.5418092\",\n \"0.5402415\",\n \"0.54015356\",\n \"0.5393227\",\n \"0.53920037\",\n \"0.5384717\",\n \"0.5384717\",\n \"0.5384717\",\n \"0.5381068\",\n \"0.53771704\",\n \"0.5375933\",\n \"0.53716\",\n \"0.5370175\",\n \"0.536531\",\n \"0.5353076\",\n \"0.5349269\",\n \"0.534405\",\n \"0.5336683\",\n \"0.5334404\",\n \"0.53322655\",\n \"0.53313214\",\n \"0.5314561\",\n \"0.5314561\",\n \"0.5307938\",\n \"0.5298948\",\n \"0.5283195\",\n \"0.5268926\",\n \"0.52688473\",\n \"0.5265227\",\n \"0.526392\",\n \"0.52555835\",\n \"0.5243347\",\n \"0.5241348\",\n \"0.52382857\",\n \"0.52369785\",\n \"0.5225406\",\n \"0.52213395\",\n \"0.52213395\",\n \"0.52176785\",\n \"0.52176785\",\n \"0.5210682\",\n \"0.5209672\",\n \"0.5208581\",\n \"0.5208516\",\n \"0.52082384\",\n \"0.52056503\",\n \"0.5194234\",\n \"0.51907253\",\n \"0.5189849\",\n \"0.5181321\",\n \"0.5178837\",\n \"0.5178417\",\n \"0.5169882\",\n \"0.5169874\",\n \"0.51693195\",\n \"0.51668674\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7861807"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":44,"numItemsPerPage":100,"numTotalItems":95772,"offset":4400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzgwNjYzOCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM4MTAyMzgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.lMFYdmitQt3DNdbKiYK7zFzFKd5Qw93zhtPaA3KR0TWOStGc4Y_dIcfujAhcjQXdpnjeb4YPZUPEdtZoeYGuCw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102 values |
|---|---|---|---|---|---|---|
Return list of values for each div.test element. | def div_value_list(self):
return self.q(css='div.test').attrs('value') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def div_text_list(self):\n return self.q(css='div.test').text",
"def div_html_list(self):\n return self.q(css='div.test').html",
"def get_individual_performance(self):\n\n divs = self.page.find_all(\"span\", {\"class\":\"value\"})\n values = [div.text for div in divs]\n retur... | [
"0.74490196",
"0.68997157",
"0.64932024",
"0.61540717",
"0.6152504",
"0.6152504",
"0.5885815",
"0.58685976",
"0.5835421",
"0.58142436",
"0.57759404",
"0.5746933",
"0.56337065",
"0.5621383",
"0.5567706",
"0.5559967",
"0.55586827",
"0.55545664",
"0.5553262",
"0.5503301",
"0.548... | 0.7983814 | 0 |
Return list of html for each div.test element. | def div_html_list(self):
return self.q(css='div.test').html | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def div_text_list(self):\n return self.q(css='div.test').text",
"def test_html(self):\n tags = (('<input', 3),\n ('<span', 1),\n ('<button', 1))\n\n for text, count in tags:\n with self.subTest():\n self.assertContains(self.resp, text, ... | [
"0.7729957",
"0.62460953",
"0.62029403",
"0.601013",
"0.597623",
"0.5949348",
"0.58157754",
"0.5773843",
"0.56723",
"0.5651943",
"0.5582805",
"0.5582524",
"0.5579697",
"0.55494183",
"0.5474166",
"0.54684716",
"0.5461556",
"0.5445097",
"0.5445097",
"0.54369843",
"0.54336387",
... | 0.8394743 | 0 |
Return a list of the ids of outer divs with the specified text in a child element. | def ids_of_outer_divs_with_inner_text(self, child_text):
return self.q(css='div.outer').filter(
lambda el: child_text in [inner.text for inner in el.find_elements_by_css_selector('div.inner')]
).attrs('id') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ids(self):\n page = r.get(self.url)\n tree = html.fromstring(page.content)\n ids_elements = tree.xpath(\"//div[@id='selectedcontent']/div/ul/li/a\")\n return [self._e_to_id(e) for e in ids_elements]",
"def get_child_ids(id,conn):\n\n child_ids = ('WITH RECURSIVE children AS '\n ... | [
"0.55548036",
"0.5479126",
"0.54318756",
"0.54250884",
"0.53954",
"0.5378344",
"0.5358235",
"0.532862",
"0.53090286",
"0.52930194",
"0.5247154",
"0.5223819",
"0.5181133",
"0.51650614",
"0.5156875",
"0.51566947",
"0.512827",
"0.5109152",
"0.5081774",
"0.5059653",
"0.5021192",
... | 0.877173 | 0 |
Wait for click handlers to be installed, then click a button and retrieve the output that appears after a delay. | def trigger_output(self):
EmptyPromise(self.q(css='div#ready').is_present, "Click ready").fulfill()
self.q(css='div#fixture button').first.click()
EmptyPromise(self.q(css='div#output').is_present, "Output available").fulfill() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trigger_output(self):\n self.q(css='div#fixture button').first.click()",
"def trigger_output(self):\n self.q(css='div#fixture button').first.click()",
"def wait_for_click():\r\n global _canvas\r\n global _cue\r\n if _canvas == None:\r\n raise RuntimeError(\"Canvas is not open ... | [
"0.6465646",
"0.6465646",
"0.6274144",
"0.62248296",
"0.6096584",
"0.6029719",
"0.5998305",
"0.5964109",
"0.5912692",
"0.58695084",
"0.5805828",
"0.5800075",
"0.5798295",
"0.5771682",
"0.5740042",
"0.5727599",
"0.5700866",
"0.56949717",
"0.56949717",
"0.56891507",
"0.5687063"... | 0.66481423 | 0 |
Make a promise that will not be fulfilled. Should raise a `BrokenPromise` exception. | def make_broken_promise(self):
return EmptyPromise(
self.q(css='div#not_present').is_present, "Invalid div appeared",
try_limit=3, try_interval=0.01
).fulfill() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def promise_forced(promise):\n require_type(isa(promise,Promise),\n 'the parameter of promise_forced must be a Promise')\n return promise.exprs.env.find(Symbol('already-run?'))['already-run?']",
"async def test_task_not_awaitable(arg):\n with pytest.raises(OSError):\n async with Scope(... | [
"0.5204269",
"0.5157995",
"0.5118575",
"0.50748104",
"0.5045879",
"0.50228643",
"0.48635247",
"0.48367554",
"0.48231182",
"0.48055142",
"0.48020154",
"0.4710334",
"0.4705783",
"0.47007585",
"0.4683378",
"0.4586624",
"0.45848158",
"0.45210996",
"0.45157987",
"0.449673",
"0.449... | 0.7172702 | 0 |
Load the page named `page_name` after waiting for `delay_sec`. | def load_next(self, page, delay_sec):
time.sleep(delay_sec)
page.visit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_page_content(self, url, delay):\r\n\r\n # if browser cannot connect to the server, repeat it infinitely.\r\n while True:\r\n try:\r\n # load the page\r\n self.sel_driver.get(url)\r\n\r\n # if the page is loaded, wait for delay seconds un... | [
"0.6076569",
"0.60745835",
"0.5974487",
"0.5962621",
"0.589742",
"0.58021855",
"0.5790462",
"0.5778986",
"0.5760904",
"0.5742551",
"0.55892485",
"0.555522",
"0.55303234",
"0.550315",
"0.5468579",
"0.54579824",
"0.54159063",
"0.5409639",
"0.53982323",
"0.53721374",
"0.5353541"... | 0.7595584 | 0 |
Give focus to the element with the ``maincontent`` ID. | def focus_on_main_content(self):
self.browser.execute_script("$('#main-content').focus()") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SetFocus(self):\r\n \r\n self._main_win.SetFocus()",
"def onMnemoToMain(self):\n self.second_main_text.SetFocus()",
"def _focus(self, element):\n actions = ActionChains(self.selenium.driver)\n actions.move_to_element(element).click().perform()\n self.selenium.set_f... | [
"0.68469656",
"0.64330465",
"0.62243736",
"0.5957323",
"0.5938014",
"0.59248924",
"0.59248924",
"0.59248924",
"0.59248924",
"0.58128226",
"0.56373054",
"0.5598049",
"0.5598049",
"0.5598049",
"0.5598049",
"0.55663764",
"0.555354",
"0.55340254",
"0.5431309",
"0.5403516",
"0.537... | 0.8871579 | 0 |
Return a boolean indicating whether the given item is visible. | def is_visible(self, name):
return self.q(css="div.{}".format(name)).first.visible | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def IsItemVisible(self, item):\r\n\r\n # An item is only visible if it's not a descendant of a collapsed item\r\n parent = item.GetParent()\r\n\r\n while parent:\r\n \r\n if not parent.IsExpanded():\r\n return False\r\n \r\n parent = paren... | [
"0.8459566",
"0.84089726",
"0.77478164",
"0.7686081",
"0.75969285",
"0.73080444",
"0.7240645",
"0.7220778",
"0.7220778",
"0.72025424",
"0.71858346",
"0.7166278",
"0.7160818",
"0.7160818",
"0.71175337",
"0.7071212",
"0.7057632",
"0.70267516",
"0.70217055",
"0.70079386",
"0.697... | 0.7075357 | 15 |
Return a boolean indicating whether the given element is present, but not visible. | def is_invisible(self, name):
return self.q(css="div.{}".format(name)).first.invisible | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_element_visible(self):\n if self.web_element.is_displayed():\n return True\n else:\n return False",
"def is_visible(self):\n try:\n return self.element.is_displayed()\n except (NoSuchElementException,\n ElementNotVisibleException,... | [
"0.79927605",
"0.76851815",
"0.7514392",
"0.73334104",
"0.72232956",
"0.7165965",
"0.7094234",
"0.704868",
"0.70152134",
"0.6991982",
"0.6934526",
"0.6922148",
"0.6860868",
"0.67825663",
"0.6755709",
"0.6745916",
"0.67344236",
"0.6696617",
"0.66683865",
"0.6668148",
"0.656032... | 0.64932275 | 24 |
Click a button which will only work once RequireJS finishes loading. | def trigger_output(self):
self.q(css='div#fixture button').first.click() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def click_button(self):\n self.widgets.get('button').click()",
"def click_button(self):\n self.q(css='div#fixture button').first.click()",
"def click(self):\n self.dispatch['elementClick'] = self.clickJsFnc",
"def click_button(self):\n self.q(css='div#fixture input').first.click()",
... | [
"0.680854",
"0.66910315",
"0.64084864",
"0.6336114",
"0.6120209",
"0.61122954",
"0.61030865",
"0.6091507",
"0.6059248",
"0.5980037",
"0.59742665",
"0.5892647",
"0.5888682",
"0.5856755",
"0.58410084",
"0.5814442",
"0.581181",
"0.5751456",
"0.57503045",
"0.5749024",
"0.5719854"... | 0.59564984 | 12 |
Reload the page, wait for JS, then trigger the output. | def reload_and_trigger_output(self):
self.browser.refresh()
self.wait_for_js() # pylint: disable=no-member
self.q(css='div#fixture button').first.click() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh_page(self):\n self.m_driver.refresh()\n time.sleep(30)",
"def refresh(self):\n self.log_info(f\"Browser.refresh: Refreshing the page\")\n self.CORE.refresh()\n return",
"def refresh_page(self, callback=None):\n if callback is not None:\n callback... | [
"0.61143285",
"0.6020823",
"0.5730542",
"0.5707968",
"0.5650479",
"0.5597226",
"0.5587973",
"0.5548144",
"0.55204254",
"0.55047655",
"0.54316336",
"0.53578436",
"0.5348964",
"0.5344503",
"0.52896523",
"0.5284119",
"0.5284119",
"0.5281825",
"0.52662414",
"0.5262159",
"0.524401... | 0.77481604 | 0 |
Click a button which will only work once RequireJS finishes loading. | def trigger_output(self):
self.q(css='div#fixture button').first.click() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def click_button(self):\n self.widgets.get('button').click()",
"def click_button(self):\n self.q(css='div#fixture button').first.click()",
"def click(self):\n self.dispatch['elementClick'] = self.clickJsFnc",
"def click_button(self):\n self.q(css='div#fixture input').first.click()",
... | [
"0.6809526",
"0.6691951",
"0.6409184",
"0.63370335",
"0.61212236",
"0.611287",
"0.6103311",
"0.6092065",
"0.606103",
"0.59802353",
"0.5975364",
"0.5893435",
"0.58887005",
"0.5856853",
"0.5842421",
"0.5815631",
"0.5811794",
"0.5753243",
"0.57503897",
"0.5748913",
"0.5719881",
... | 0.59564173 | 11 |
Wait for scripts to finish and then return the contents of the ``output`` div on the page. | def output(self):
return super(RequireJSPage, self).output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait(self):\n\t\tself.wait_window(self)\n\t\treturn self.result",
"def waitUntilFinished():",
"def waitUntilFinished():",
"def waitUntilFinished():",
"def waitUntilFinished():",
"def trigger_output(self):\n\n EmptyPromise(self.q(css='div#ready').is_present, \"Click ready\").fulfill()\n ... | [
"0.58988714",
"0.5896934",
"0.5896934",
"0.5896934",
"0.5896934",
"0.5818085",
"0.5690976",
"0.56339425",
"0.5543673",
"0.5390721",
"0.5287882",
"0.52217585",
"0.5208909",
"0.51837784",
"0.5157287",
"0.5146636",
"0.51380193",
"0.51380193",
"0.51380193",
"0.51380193",
"0.51246... | 0.0 | -1 |
Click the button on the page, which triggers an ajax call that updates the output div. | def click_button(self):
self.q(css='div#fixture button').first.click() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trigger_output(self):\n self.q(css='div#fixture button').first.click()",
"def trigger_output(self):\n self.q(css='div#fixture button').first.click()",
"def reload_and_trigger_output(self):\n self.browser.refresh()\n self.wait_for_js() # pylint: disable=no-member\n self.q... | [
"0.6879377",
"0.6879377",
"0.6518393",
"0.6406209",
"0.62057817",
"0.61877733",
"0.61342907",
"0.6104341",
"0.6008106",
"0.5944604",
"0.5852779",
"0.5775311",
"0.5756694",
"0.57321346",
"0.5669197",
"0.56490207",
"0.5648505",
"0.5631494",
"0.5623206",
"0.5592204",
"0.5576342"... | 0.641759 | 3 |
Click button and wait until output id appears in DOM. | def is_button_output_present(self):
self.wait_for_element_presence('div#ready', 'Page is Ready')
self.q(css='div#fixture button').first.click()
self.wait_for_element_presence('div#output', 'Button Output is Available') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trigger_output(self):\n self.q(css='div#fixture button').first.click()",
"def trigger_output(self):\n self.q(css='div#fixture button').first.click()",
"def trigger_output(self):\n\n EmptyPromise(self.q(css='div#ready').is_present, \"Click ready\").fulfill()\n self.q(css='div#fix... | [
"0.7427304",
"0.7427304",
"0.73659456",
"0.69929504",
"0.6745575",
"0.6593339",
"0.62362456",
"0.6128253",
"0.5971103",
"0.59329253",
"0.59204847",
"0.5899554",
"0.5845453",
"0.58411074",
"0.5840437",
"0.5811588",
"0.58096135",
"0.58032614",
"0.5756631",
"0.57544845",
"0.5751... | 0.71300626 | 3 |
Click button and wait until playing class disappeared from DOM | def is_class_absent(self):
self.q(css='#spinner').first.click()
self.wait_for_element_absence('.playing', 'Animation Stopped') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def poll(self):\n\tself.met = self.button.poll()",
"def wait_for_button(self, button, message=True):\n if message:\n rospy.loginfo(\"Waiting for xbox button: \" + button)\n \n wait_for(lambda: not self.get_button(button) == 0)",
"def _check_play_button(self, mouse_pos):\n ... | [
"0.6262264",
"0.6247249",
"0.6172894",
"0.6123498",
"0.6084997",
"0.6075153",
"0.60310066",
"0.6026245",
"0.60012144",
"0.5995387",
"0.5967095",
"0.59577924",
"0.5948899",
"0.59429574",
"0.592757",
"0.5881039",
"0.5876616",
"0.5875502",
"0.58591527",
"0.5838041",
"0.58163005"... | 0.6424565 | 0 |
Click button and wait until output is displayed. | def is_button_output_visible(self):
self.wait_for_element_presence('div#ready', 'Page is Ready')
self.q(css='div#fixture button').first.click()
self.wait_for_element_visibility('div#output', 'Button Output is Visible') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trigger_output(self):\n self.q(css='div#fixture button').first.click()",
"def trigger_output(self):\n self.q(css='div#fixture button').first.click()",
"def trigger_output(self):\n\n EmptyPromise(self.q(css='div#ready').is_present, \"Click ready\").fulfill()\n self.q(css='div#fix... | [
"0.7492994",
"0.7492994",
"0.74046254",
"0.73170245",
"0.6892896",
"0.67912996",
"0.6658468",
"0.66095304",
"0.66076696",
"0.6600129",
"0.64885914",
"0.6422199",
"0.63829",
"0.63829",
"0.6375364",
"0.63732177",
"0.6356924",
"0.63511723",
"0.6327557",
"0.62831944",
"0.62803334... | 0.67361134 | 6 |
Click button and wait until spinner is disappeared. | def is_spinner_invisible(self):
self.q(css='#spinner').first.click()
self.wait_for_element_invisibility('#anim', 'Button Output is Visible') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait_spinner_disappear(self):\n self.wait_for_element_disappear(loadings_catalog.LOADING_SPINNER)\n self.wait_for_element_disappear(loadings_catalog.LOADING)",
"def wait_for_button(self, button, message=True):\n if message:\n rospy.loginfo(\"Waiting for xbox button: \" + butto... | [
"0.7126271",
"0.6884283",
"0.66924036",
"0.65854484",
"0.654948",
"0.64384645",
"0.63156706",
"0.62573993",
"0.62523603",
"0.6224479",
"0.61823416",
"0.61524755",
"0.6134778",
"0.61076003",
"0.6089265",
"0.6077746",
"0.6075494",
"0.606039",
"0.6058926",
"0.6032544",
"0.603163... | 0.69422036 | 1 |
Determine if a given blockchain is valid | def valid_chain(self, chain):
last_block = chain[0]
current_index = 1
while current_index < len(chain):
block = chain[current_index]
# print(f'{last_block}')
# print(f'{block}')
# print("\n-----------\n")
# Check that the hash of the block is correct
last_block_hash = self.hash(last_block)
if block['previous_hash'] != self.hash(last_block):
return False
# Check that the Proof of Work is correct
if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash):
return False
last_block = block
current_index += 1
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validChain(bc):\n #If the first block of chain is not equal to the genesis block, then chain is invalid\n if (json.dumps(Block.to_dict(bc.chain[0])) != json.dumps(Block.to_dict(Block.genesis()))):\n return False\n #check validity for all blocks in the blockchain\n for i i... | [
"0.763013",
"0.7623251",
"0.76183456",
"0.7577117",
"0.7567591",
"0.7553642",
"0.74016935",
"0.7393162",
"0.7381024",
"0.7346507",
"0.73355687",
"0.7174818",
"0.71236986",
"0.71236986",
"0.7094909",
"0.70591253",
"0.7049671",
"0.69781476",
"0.69487953",
"0.694765",
"0.6893976... | 0.69277084 | 20 |
Creates a SHA256 hash of a Block | def hash(block):
# We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes
block_string = json.dumps(block, sort_keys=True).encode()
return hashlib.sha256(block_string).hexdigest() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash_block(self):\n sha = hasher.sha256()\n sha.update((str(self.index) + str(self.timestamp) + str(self.data) + str(self.previous_hash)).endswith('utf-8'))\n return sha.hexdigest()",
"def compute_hash(block):\n block_string = json.dumps(self.__dict__, sort_keys= True)\n re... | [
"0.79220486",
"0.79210114",
"0.7906467",
"0.7823901",
"0.7823901",
"0.78018546",
"0.7720867",
"0.76859254",
"0.7677476",
"0.7630424",
"0.7623705",
"0.7534247",
"0.7505899",
"0.7446964",
"0.74002504",
"0.74002504",
"0.73705757",
"0.73611194",
"0.7283995",
"0.72734344",
"0.7201... | 0.7548614 | 15 |
Check if value is prime | def is_prime(value: int) -> bool:
if value == 1:
return False
if value <= 0:
raise ValueError("Value must be greater than zero")
for i in range(2, int(value**(1/2)) + 1):
if value % i == 0:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_prime(value):\n\n if value < 2: raise ValueError\n\n for i in range(2, value):\n if value % i == 0:\n return False\n\n return True",
"def is_prime(self):\n pass",
"def is_prime(value):\n if value < 4:\n return True\n \n lower_bound = 2\n upper_bound = value-1\n... | [
"0.8251294",
"0.7981401",
"0.794535",
"0.78773165",
"0.7870162",
"0.7779645",
"0.77755505",
"0.77661145",
"0.77396506",
"0.77324396",
"0.77158386",
"0.77105474",
"0.7694114",
"0.7672864",
"0.7660135",
"0.7650814",
"0.76269066",
"0.76167756",
"0.7599302",
"0.75861603",
"0.7584... | 0.81013525 | 1 |
Get all prime factors of the given value | def factors(value: int) -> list:
prime_factors: list = []
for i in range(2, value + 1):
if i > 2 and i % 2 == 0 or not is_prime(i):
continue
while value % i == 0:
value = int(value / i)
prime_factors.append(i)
if value == 1:
break
return prime_factors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prime_factors_of(value):\n\n # Okay, so we need to \"solve\" two problems here:\n # is a given number a factor of `value`?\n # and\n # is a given number PRIME?\n\n # I think the simplest non-stupid approach is to generate all \n # FACTORS OF VALUE, and then check to see which are prime!\n ... | [
"0.8195275",
"0.8172038",
"0.78768766",
"0.78615814",
"0.78161514",
"0.7815678",
"0.78074765",
"0.7803163",
"0.7796986",
"0.7784412",
"0.77701026",
"0.7747795",
"0.77219456",
"0.7687131",
"0.766128",
"0.76611435",
"0.76522994",
"0.7594097",
"0.75423145",
"0.7516391",
"0.75087... | 0.85676354 | 0 |
Load the image located at the specified path | def _setup_image(self, image_path):
if not os.access(image_path, os.R_OK):
rospy.logerr("Cannot read file at '{0}'".format(image_path))
return None
img = cv2.imread(image_path)
# Return msg
return cv_bridge.CvBridge().cv2_to_imgmsg(img, encoding="bgr8") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(path) -> Image:\n return Image.open(path)",
"def load_image(self, path):\n if path:\n self.original_image = cv2.imread(path, 1)\n self.prepare_images()",
"def load_image(file_path):\r\n return Image.open(file_path)",
"def load_image(path_to_image, image_name):\... | [
"0.8395559",
"0.8235641",
"0.80957776",
"0.7978053",
"0.79137325",
"0.7833698",
"0.76558286",
"0.75878996",
"0.7496194",
"0.74551564",
"0.7341567",
"0.7297161",
"0.7210053",
"0.71392775",
"0.7122944",
"0.7110663",
"0.70598626",
"0.703482",
"0.69894713",
"0.6988201",
"0.697644... | 0.0 | -1 |
Displays image(s) to robot's head | def display_image(self, image_path, display_in_loop=False, display_rate=1.0):
rospy.logdebug("Display images in loop:'{0}', frequency: '{1}'".format(display_in_loop, display_rate))
image_msg = []
image_list = image_path if isinstance(image_path, list) else [image_path]
for one_path in image_list:
cv_img = self._setup_image(one_path)
if cv_img:
image_msg.append(cv_img)
if not image_msg:
rospy.logerr("Image message list is empty")
else:
r = rospy.Rate(display_rate)
while not rospy.is_shutdown():
for one_msg in image_msg:
self._image_pub.publish(one_msg)
r.sleep()
if not display_in_loop:
break | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display(self):\n display(self.image)",
"def display_image(self, window_title: str = 'Drone Camera'):\n cv2.imshow(window_title, self.output)\n cv2.waitKey(1)",
"def display(self, image):\n raise NotImplementedError()",
"def view(self):\n window = tk.Tk()\n label ... | [
"0.71238935",
"0.67987853",
"0.66218305",
"0.6546899",
"0.6478864",
"0.6478864",
"0.636954",
"0.634819",
"0.6345504",
"0.63256186",
"0.62910193",
"0.6277586",
"0.62452334",
"0.6237978",
"0.620947",
"0.6198384",
"0.61778575",
"0.61210454",
"0.6117013",
"0.61046207",
"0.6096301... | 0.0 | -1 |
num_rays Number of beams for the simulated LiDAR. fov Field of view scan_std The standard deviation of the scan theta_disc Theta Discretization | def __init__(self, num_rays, fov, scan_std, batch_size=100):
self.batch_size = batch_size
# these were used in the old scan 2d
self.num_rays = num_rays
self.fov = fov
self.scan_std = scan_std
self.theta_inc = fov/num_rays
# often used
self.twopi = math.pi * 2
# cache vectors to send to gpu
self.output_vector = np.zeros(self.num_rays, dtype=np.float32)
self.noise = np.zeros(self.num_rays, dtype=np.float32)
self.input_vector = np.zeros((self.num_rays, 3), dtype=np.float32) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def n_rays(self):\n try: \n return self._n_rays\n except AttributeError:\n self._n_rays = 0\n for r in self.rays(): self._n_rays += 1\n return self._n_rays",
"def set_rays(self, nrays=10000, seed=6775431):\n self.NPOINT = nrays\n if (seed % ... | [
"0.61132187",
"0.5876119",
"0.56016153",
"0.53787774",
"0.531972",
"0.52205455",
"0.52205455",
"0.52205455",
"0.52205455",
"0.5152057",
"0.51412386",
"0.50477684",
"0.5036971",
"0.5029574",
"0.4998146",
"0.4961353",
"0.49178076",
"0.49124226",
"0.48896435",
"0.48728356",
"0.4... | 0.5748073 | 2 |
x Position x on the map y Position y on the map theta Direction on the map | def scan(self, x, y, theta):
# create ray list
max_theta = theta + self.fov/2.0
min_theta = theta - self.fov/2.0
thetas = np.arange(min_theta,
max_theta,
self.theta_inc,
dtype=np.float32)
self.input_vector[:, 0] = x
self.input_vector[:, 1] = y
self.input_vector[:, 2] = thetas
# run ray marching
self.scan_method.calc_range_many(self.input_vector,
self.output_vector)
return self.output_vector | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def theta(self):\n return atan2(self.y, self.x)",
"def theta(self):\n return float(np.arctan2(self.y, self.x))",
"def xy(self,theta,phi):\n dist=great_circle_distance(self.theta0,theta,self.phi0,phi)\n [yt,xt]=np.unravel_index(np.argmin(dist),dist.shape)\n return xt,yt",
"d... | [
"0.691251",
"0.683143",
"0.6619195",
"0.6595212",
"0.63898385",
"0.628581",
"0.6238489",
"0.61594254",
"0.61381114",
"0.61379653",
"0.61337817",
"0.6127042",
"0.6115421",
"0.6079736",
"0.60695887",
"0.6060793",
"0.6034483",
"0.60037607",
"0.60031086",
"0.59396416",
"0.5934096... | 0.0 | -1 |
For C,D and W unlabelled. | def get_separated_sequence():
return [("ABCDEFG", ("ABEFG", "CD")),
("ABCDEFGCDCDDC", ("ABEFG", "CDCDCDDC")),
("", ("", "")),
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label(d, X, ind_class0, ind_class1, N, V, binary):\n if binary == True:\n K = 1\n C = torch.zeros(N + V, K)\n C[ind_class0, :] = 0.0\n C[ind_class1, :] = 1.0\n else:\n K = 2\n C = torch.zeros(N + V, K)\n C[ind_class0, :] = torch.tensor([1.0, 0.0])\n ... | [
"0.5536485",
"0.54773134",
"0.52980894",
"0.52534986",
"0.52387166",
"0.5181855",
"0.5111285",
"0.508858",
"0.5086352",
"0.5073076",
"0.5041172",
"0.5002552",
"0.49880075",
"0.49566722",
"0.49318683",
"0.49224657",
"0.49038255",
"0.49009168",
"0.48969057",
"0.4893255",
"0.489... | 0.0 | -1 |
Build the actual URL to use. | def _full_url(url, _params={}):
# Support for unicode domain names and paths.
scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
if not scheme:
raise ValueError("Invalid URL %r: No schema supplied" % url)
netloc = netloc.encode('idna')
if isinstance(path, unicode):
path = path.encode('utf-8')
path = requote_path(path)
url = str(urlparse.urlunparse([scheme, netloc, path, params, query,
fragment]))
if _params:
if urlparse.urlparse(url).query:
return '%s&%s' % (url, _params)
else:
return '%s?%s' % (url, _params)
else:
return url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_url(self):\n url = BASE_URL.format(self._host, self._port)\n _LOGGER.debug(\"TOON fetch URL: %s\", url)\n return url",
"def _make_url(self):\n ...",
"def create_url(self):\n self.base_url = self.base + self.strs[jpn.path_latest]",
"def build_url(self, endpoint):\... | [
"0.82525396",
"0.80543995",
"0.7988607",
"0.7964267",
"0.79619455",
"0.7841471",
"0.77490044",
"0.77251446",
"0.77089393",
"0.76246357",
"0.75926405",
"0.75856274",
"0.7532603",
"0.75000435",
"0.74994606",
"0.74262804",
"0.742292",
"0.74154943",
"0.74154943",
"0.73670965",
"0... | 0.0 | -1 |
Sets up the connection. Will optionally accept a size or else will use a chunked TransferEncoding. | def setup(self, size=None):
if size:
self.size = size
if not self.size:
self.size = UNKNOWN_LENGTH
self.body.length = self.size
req = self.conn.make_request('PUT', self.url,
headers=self.headers,
data=self.body)
self.req = req
print "ChunkedTwistedConnection: STARTED REQUEST" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _send_connection_init(self, request: Request) -> None:\n # Need to set these manually here instead of manipulating via\n # __setitem__() otherwise the H2Connection will emit SettingsUpdate\n # frames in addition to sending the undesired defaults.\n self._h2_state.local_setting... | [
"0.5874525",
"0.58596337",
"0.57424444",
"0.57155627",
"0.571499",
"0.5675915",
"0.566236",
"0.5662341",
"0.56123924",
"0.5471748",
"0.5447842",
"0.5433867",
"0.5358979",
"0.53248644",
"0.53098845",
"0.52834433",
"0.5279242",
"0.5220655",
"0.5175288",
"0.51495194",
"0.5126971... | 0.7370442 | 0 |
Sends a chunk of data. | def send_chunk(self, chunk):
print "ChunkedTwistedConnection: send chunk"
return self.body.send(chunk) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_chunk(chunk, send_socket):\n length = len(chunk)\n data = str(length).zfill(MAX_CHUNK_SIZE).encode() + chunk\n send_socket.send(data)",
"def send_chunk(chnk, sock):\n length = len(chnk)\n data = str(length).zfill(MAX_CHUNK_SIZE).encode() + chnk\n sock.send(data)... | [
"0.78114295",
"0.7532161",
"0.7232472",
"0.71928585",
"0.7086782",
"0.7002679",
"0.6989813",
"0.69814444",
"0.69016576",
"0.68666893",
"0.68550235",
"0.6853498",
"0.67988867",
"0.6783611",
"0.67816645",
"0.67800605",
"0.6746048",
"0.6729257",
"0.6725598",
"0.67044735",
"0.670... | 0.7723083 | 1 |
Finished the request out and receives a response. | def finish(self):
self.body.finish() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finish(self):\n return self.tornado_request.finish()",
"def done(self):\n ## All done with the request object\n self.closed = True\n self.d.callback('')",
"def finished(self, reply):\n pass",
"def finish_successful_request(self):\n self.session_manager.finish_suc... | [
"0.7359422",
"0.73036295",
"0.7245725",
"0.712501",
"0.69328076",
"0.69194645",
"0.6853112",
"0.6752575",
"0.67313087",
"0.66815627",
"0.66713023",
"0.66713023",
"0.6668481",
"0.6632425",
"0.65602535",
"0.65523654",
"0.6549984",
"0.6437685",
"0.6395554",
"0.6376815",
"0.62960... | 0.6356392 | 20 |
This function will generate the file names in a directory tree by walking the tree either topdown or bottomup. For each directory in the tree rooted at directory top (including top itself), it yields a 3tuple (dirpath, dirnames, filenames). | def get_filepaths(directory):
file_paths = [] # List which will store all of the full filepaths.
# Walk the tree.
for root, directories, files in os.walk(directory):
for filename in files:
if filename.endswith('.wav'):
# Join the two strings in order to form the full filepath.
filepath = os.path.join(root, filename)
file_paths.append(filepath) # Add it to the list.
# pdb.set_trace()
file_paths.sort()
return file_paths | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def walk_tree(top):\n nodes = [top]\n for dirpath, dirnames, filenames in os.walk(top):\n for dirname in dirnames:\n nodes.append(os.path.join(dirpath, dirname))\n for filename in filenames:\n nodes.append(os.path.join(dirpath, filename))\n\n return nodes",
"def walkt... | [
"0.74382895",
"0.73284924",
"0.6859594",
"0.6823699",
"0.6807483",
"0.67260796",
"0.6721552",
"0.6637687",
"0.6594345",
"0.6485284",
"0.6484495",
"0.6478459",
"0.64450955",
"0.6372701",
"0.63717425",
"0.63453346",
"0.6339544",
"0.6330374",
"0.6294579",
"0.62940586",
"0.627964... | 0.0 | -1 |
Calculate the distance and rotation to the edge of the desk | def getDistanceAndRotationToEdge(l, f, r):
if DEBUG:
print "lfr:", l,",",f,",",r
# Maths help from: http://xaktly.com/MathNonRightTrig.html
# - Specfically the law of cosines, but at least one of their
# examples is wrong, but methods are correct... sigh.
#
# For triangle with forward length, shortest of
# left and right length, and desk edge as sides...
#
# f = forward distance length
# l = left distance length
# r = right distance length
# e = length of desk edge between left and right views
# s = shortest of left and right distance length
# v = "view" angle of how much robot looks left or right
# g = angle between f and e
# d = distance between robot and edge of desk
# a = angle between the way the robot is facing and edge of desk
# (i.e. if the robot is facing directly towards edge it's 0)
# (in radians or degrees?..)
#
# e² = f² + s² - 2 * f * s * cos(v)
# g = sin⁻¹ * (s * sin(v) / e)
# d = f * sin(g)
# a = 180 - 90 - g (minus or positive depending on if s is left or right)
# Figure out if the edge of the desk is more to the right or left
# s = min(l, r) <-- Used to use this, but need additional things.
# r | l | s
# x | x | ?
# 1 | 1 | ? Logic table for _r_ight, _l_eft, and output
# 0 | 0 | ? _s_hortest distances from robot to desk edge
# x | 0 | l
# 1 | x | r x = None
# 0 | 1 | r 1 = arbitrary high-ish value
# x | 1 | l 0 = arbitrary low-ish value
# 1 | 0 | l
# 0 | x | r
# Distance to right and left are missing?
if r is None and l is None:
if DEBUG:
print "INFO: Skipping edge calcs because of missing distances."
return int(round(f)), 0
# Distance to right and left identical?
elif r == l:
if DEBUG:
print "INFO: Skipping edge calcs because of identical distances."
# This is unlikely-ish because l, f, r are floats...
#
# r < f r > f
# ◆ | or ◼
# ____➘| __🠛__
#
return int(round(min(r, f))), 0
# Figure out if _l_eft or _r_ight is the shorter distance
else:
if r is None:
s = l
direction = -1
elif l is None:
s = r
direction = 1
elif l < r:
s = l
direction = -1
elif r < l :
s = r
direction = 1
cosV = math.cos(math.radians(45))
sinV = math.sin(math.radians(45))
e = f**2 + s**2 - 2 * f * s * cosV
e = math.sqrt(e)
g = math.degrees(math.asin(s * sinV / e))
d = f * math.sin(math.radians(g)) # Switching degrees/radians f'debugging
a = (90 - g) * direction
'''
# Debug stuff
print "f =", f
print "l =", l
print "r =", r
print "e =", e
print "s =", s
print "v =", 45
print "g =", g
print "d =", d
print "a =", a
'''
distance = int(round(d))
rotation = int(round(a))
if DEBUG:
print "Distance to edge:", str(distance) + "cm"
print "Rotation to edge:", str(rotation) + "°"
return distance, rotation | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getEdgeAngle():\n '''\n returns angle a\n a\n ◿\n b c\n '''\n ANGLE_OFFSET = 8 # How far off the angle measurements are in degrees.\n THRESHOLD = 220 # How much light must be reflected to 'notice' the desk.\n angle = 0\n while angle < panTilt.TLT_RANGE:\n ... | [
"0.6792521",
"0.67125314",
"0.6442544",
"0.6154413",
"0.5941092",
"0.5854384",
"0.58526313",
"0.5838844",
"0.58166885",
"0.5809942",
"0.57968384",
"0.5790198",
"0.5733752",
"0.57309914",
"0.5662172",
"0.5659722",
"0.5644403",
"0.5641197",
"0.5620599",
"0.55770284",
"0.5569615... | 0.6808179 | 0 |
Given a value break it down by the ilk of node (usb or pci), the vendor, and the device or product. | def parse_value(value: str) -> Tuple[str, str, str]:
value_pattern = r'^(usb|pci)\(([^:]{4}):([^:]{4})\)$'
matches = re.match(value_pattern, value)
assert matches, value
ilk, vendor, device = matches.group(1), matches.group(2), matches.group(3)
return ilk, vendor, device | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vendor_list():\n return ['nxos', 'eos', 'cumulus']",
"def get_vendor(mac):\r\n return p.get_manuf(mac) or 'None'",
"def bios_vendor(self):\n\t\treturn self.__info_dict['info']['bios_vendor']['value']",
"def device_catalog_path_value_converter(value):\n paths = []\n for path in value:\n ... | [
"0.57974625",
"0.5661134",
"0.56355417",
"0.55662423",
"0.5533631",
"0.5503334",
"0.5503334",
"0.5503334",
"0.5503334",
"0.5503334",
"0.5503334",
"0.5413959",
"0.53457385",
"0.5296801",
"0.52907497",
"0.52587706",
"0.52237445",
"0.52177995",
"0.52067405",
"0.517088",
"0.51611... | 0.6276907 | 0 |
Since the ventricle is usually not convex, using radial coordinates can be misleading. A simple search deals with the proper order of the points and ensures a singlepixel edge. | def _walk_on_edge(self, coordinates_of_edge):
sorted_edge = list()
edge_points = list()
self.distance_matrix = cdist(coordinates_of_edge, coordinates_of_edge, metric='euclidean')
self.distance_matrix[self.distance_matrix == 0] = 100
cur_point = list(min(coordinates_of_edge, key=lambda t: t[1]))
sorted_edge.append(cur_point)
while 1:
try:
new_point, flag = self._find_closest_point(coordinates_of_edge, cur_point, sorted_edge)
except TypeError:
plt.scatter(sorted_edge, s=1)
plt.xlim((0, 256))
plt.ylim((-256, 0))
self._save_failed_qc_image('Search for new point failed')
break
if flag:
edge_points.append(cur_point)
if len(edge_points) == 2:
break
sorted_edge.reverse()
cur_point = sorted_edge[-1]
else:
cur_point = new_point
sorted_edge.append(cur_point)
basal_septal_edge = min(edge_points, key=lambda x: x[0])
if np.all(basal_septal_edge != sorted_edge[0]):
sorted_edge.reverse()
return sorted_edge | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indices ( self, *r):\n \n if len(r) == 3: # only 3 values given -> use x,y,radius method\n xpos = self.gpos\n xis = []\n yis = []\n dr2 = (xpos[0, :]-r[0])**2 + (xpos[1, :]-r[1])**2\n # array with true/false entries\n inds = dr2 <=... | [
"0.6597289",
"0.6597289",
"0.65620327",
"0.61580426",
"0.6140572",
"0.60876256",
"0.6040511",
"0.59974813",
"0.59635466",
"0.59572154",
"0.5936011",
"0.58943766",
"0.58940417",
"0.586778",
"0.5863292",
"0.58565116",
"0.5846335",
"0.5845742",
"0.5843002",
"0.582725",
"0.582498... | 0.0 | -1 |
Initialisation, where df is a pandas DataFrame and var is the name of the column to study and init_pars is a dictionary with initial values | def __init__(self, df, Z, Q, H, T, R, d, c, var='dep_var', secondvar=None, method='iterate'):
self.method = method
# Initialize all the system matrices as attributes of the class
self.Z = Z
self.Q = Q
self.H = H
self.T = T
self.R = R
self.d = d
self.c = c
# same for parameters and objects
self.df = df
self.var = var
# The data itself
self.y = np.array(df[var].values.flatten())
self.times = df.index
# Options for the minimizer
self.options = {'eps': 1e-09,
'maxiter': 200} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self,df, init_pars, var='dep_var', var_name='Volume of Nile'):\n self.df = df\n self.var = var\n self.var_name = var_name\n self.y = np.array(df[var].values.flatten())\n self.times = df.index\n self.pardict = init_pars\n self.options = {'eps':1e-09,\n ... | [
"0.7032874",
"0.5726817",
"0.55134976",
"0.5488105",
"0.5354998",
"0.5293255",
"0.5284768",
"0.5283604",
"0.52450967",
"0.52211875",
"0.5218443",
"0.52158165",
"0.5208098",
"0.5172965",
"0.51615965",
"0.5151945",
"0.513557",
"0.51037365",
"0.5097976",
"0.5087936",
"0.50831324... | 0.5161708 | 14 |
likelihood function of state space model, to be optimized by minimizer. Pass parameter vector to it and obtain likelihood | def __llik_fun__(self, par_ini):
n = len(self.y)
# Only the normal KFS
if self.method == 'iterate':
_, __, P, v, F = self.iterate(plot=False, estimate=True, init_params=par_ini)
# KSF with regression coefficient (beta)
elif self.method == 'iterateRegression':
_, __, P, v, F = self.iterateRegression(plot=False, estimate=True, init_params=par_ini)
L= -(n / 2)*np.log(2*np.pi) - 0.5 * np.sum(np.log(np.abs(F[1:]))) - 0.5 * np.sum((v[1:] ** 2) / F[1:]) #+ np.log(self.P_start)
# Return negative likelihood since we minimize it with the minimizier
return (-1)*L | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def likelihood(\n self,\n observation: np.ndarray,\n state: np.ndarray,\n control_z: Optional[np.ndarray] = None\n ) -> np.matrix:\n pass",
"def log_likelihood(self, data, reward_model, bias_params):",
"def __log_likelihood(self, params, *args):\n\t\tX, y, ... | [
"0.7302444",
"0.7227682",
"0.7056718",
"0.704548",
"0.7038803",
"0.6894036",
"0.68110865",
"0.67771643",
"0.67480403",
"0.669332",
"0.6690634",
"0.66567886",
"0.6648611",
"0.6637662",
"0.6605316",
"0.6598561",
"0.65950495",
"0.6588439",
"0.6587018",
"0.65525615",
"0.65012264"... | 0.6453411 | 23 |
Optimize model by maximizing the likelihood | def fit_model(self, phi, omega, sigma_eta, beta=0):
# Initialize at the initial values parsed to the class
par_ini = [phi, omega, sigma_eta, beta]
# Approximate the jabocian for more efficient minimization
Lprime = lambda x: approx_fprime(x, self.__llik_fun__, 0.01)
if self.method == 'iterateRegression':
# Depending on whether we include the regression coefficient, use other optimizer
est = minimize(self.__llik_fun__, x0=par_ini,
options=self.options,
method='Newton-CG', jac=Lprime)
else:
est = minimize(self.__llik_fun__, x0=par_ini,
options=self.options,
method='BFGS')
# Return optimal parameters
return est.x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimize(self): \n if self.model == 'ARD':\n estimate = minimize(\n fun=optim_func,\n x0=np.array([self.alpha, self.beta]),\n args=(self,),\n method='L-BFGS-B',\n bounds=((0, 50), (0, 50)),\n )\n ... | [
"0.7011556",
"0.67614967",
"0.6661641",
"0.64753014",
"0.6324813",
"0.6313172",
"0.62755656",
"0.62447",
"0.6160573",
"0.6111164",
"0.60700196",
"0.60524917",
"0.60361964",
"0.6025766",
"0.6025012",
"0.6023183",
"0.60038626",
"0.600292",
"0.598566",
"0.59753746",
"0.59354776"... | 0.5914919 | 22 |
Iterate over the observations and update the filtered values after each iteration | def iterate(self, plot=True, estimate=False, init_params=None):
# Create empty arrays to store values
F = np.zeros(len(self.y))
a = np.zeros(len(self.y))
v = np.zeros(len(self.y))
P = np.zeros(len(self.y))
# Initialize at the initial values parsed to the class
if estimate == True:
self.T = np.array(init_params[0])
self.c = np.array(init_params[1])
self.R = np.array(init_params[2])
# self.H = np.array(init_params[0])
# self.Q = np.array(init_params[1])
P[0] = self.P_start
a[0] = self.a_start
# Iterate over the observatios
for t in range(0, len(self.y) - 1):
# Kalman filter equations
v[t] = self.y[t] - self.Z * a[t] - self.d
F[t] = self.Z * P[t] * self.Z.transpose() + self.H
a_t = a[t] + ((P[t] * self.Z.transpose()) / F[t]) * v[t]
a[t + 1] = self.T * a_t + self.c
P_t = P[t] - ((P[t] * self.Z.transpose()) / F[t]) * self.Z * P[t]
P[t + 1] = self.T * P_t * self.T.transpose() + self.R * self.Q * self.R.transpose()
F[-1] = P[-1] + self.H
v[-1] = self.y[-1] - a[-1]
# Obtain std error of prediction form variance
std = np.sqrt((P * self.H) / (P + self.H))
return a, std, P, v, F | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, other):\n for filter, value in other.items():\n self.__setitem__(filter, value)",
"def update(self):\n for filter in self.filters:\n filter.update(self.learning_rate)",
"def update(self, updates, predicate):\n for row in self.rows:\n if predicate(row... | [
"0.63613224",
"0.62198365",
"0.6080035",
"0.60798997",
"0.60306054",
"0.58865666",
"0.5883915",
"0.58141124",
"0.5800074",
"0.5787996",
"0.5541149",
"0.5536493",
"0.55307084",
"0.5513393",
"0.55123764",
"0.5507698",
"0.54158753",
"0.5414475",
"0.5403888",
"0.53936756",
"0.538... | 0.0 | -1 |
Iterate over the observations and update the filtered values after each iteration | def iterateRegression(self, plot=True, estimate=False, init_params=None):
# Create empty arrays to store values
F = np.zeros(len(self.y))
a_b = np.zeros((2,len(self.y))) # alphas and betas
v = np.zeros(len(self.y))
P = np.zeros((len(self.y),2,2))
# Initialize at the initial values parsed to the class
if estimate == True:
self.T = np.array([[init_params[0],0],[0,1]])
self.c = np.vstack(([init_params[1],0]))
self.R = np.vstack(([init_params[2]],[0]))
self.a_start = np.vstack(([self.alpha_mean], [init_params[3]]))
P[0,:,:] = self.P_start
a_b[:,0:1] = self.a_start
# Iterate
for t in range(0, len(self.y) - 1):
# Slightly different updating equations for KF since we now have regression coefficient
v[t] = self.y[t] - np.dot(self.Z[:,t:t+1].T,a_b[:,t]) - self.d
F[t] = np.dot(np.dot(self.Z[:,t:t+1].T, P[t]),self.Z[:,t:t+1]) + self.H
a_t = a_b[:,t:t+1] + np.dot(P[t],self.Z[:,t:t+1] / F[t]) * v[t]
a_b[:,t + 1:t+2] = np.dot(self.T, a_t) + self.c
P_t = P[t] - np.dot((np.dot(P[t],self.Z[:,t:t+1]) / F[t]),np.dot(self.Z[:,t:t+1].T, P[t]))
P[t + 1,:,:] = np.dot(np.dot(self.T, P_t),self.T.transpose()) + np.dot(self.R * self.Q,self.R.transpose())
F[-1] = np.dot(np.dot(self.Z[:,-1:].T, P[-1]),self.Z[:,-1:]) + self.H
v[-1] = self.y[-1] - a_b[0,-1:]
# Obtain std error of prediction form variance
std = np.sqrt((P[:,0,0] * self.H) / (P[:,0,0] + self.H))
return a_b, std, P, v, F | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, other):\n for filter, value in other.items():\n self.__setitem__(filter, value)",
"def update(self):\n for filter in self.filters:\n filter.update(self.learning_rate)",
"def update(self, updates, predicate):\n for row in self.rows:\n if predicate(row... | [
"0.63613224",
"0.62198365",
"0.6080035",
"0.60798997",
"0.60306054",
"0.58865666",
"0.5883915",
"0.58141124",
"0.5800074",
"0.5787996",
"0.5541149",
"0.5536493",
"0.55307084",
"0.5513393",
"0.55123764",
"0.5507698",
"0.54158753",
"0.5414475",
"0.5403888",
"0.53936756",
"0.538... | 0.0 | -1 |
I have some docs | def docs(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def document(self):\n ...",
"def get_docs(self):\n return self.retrieve_docstring()",
"def get_docs(self):\n return self.retrieve_docstring()",
"def get_docs(self):\n return self.retrieve_docstring()",
"def docs(self):\n self._doc_info = DocumentationURL()\n self._... | [
"0.7454927",
"0.7446354",
"0.7446354",
"0.7446354",
"0.73413706",
"0.7109946",
"0.71089756",
"0.7055562",
"0.70452785",
"0.69460195",
"0.68773216",
"0.6874397",
"0.6845154",
"0.6833291",
"0.67916155",
"0.66953266",
"0.6682665",
"0.66622543",
"0.66396433",
"0.66306525",
"0.656... | 0.87407255 | 0 |
get filename as argument from user or if not given, take filename interactively. Return file handle | def get_filename_as_agrv_if_no_ask(prompt):
Found = False
ln = len(sys.argv)
while not Found:
if ln < 2:
file = input( prompt)
else:
file = sys.argv[1]
try:
RFH = open(file)
Found = True
except FileNotFoundError:
print("%%Error! File not found!")
ln = 1
# break
return RFH | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def obtain_filename():\n file_wanted = input(\"Filename? \")\n return file_wanted",
"def askInputFile():\n while True:\n print(\"Enter a valid .txt file\")\n # Try until a plain-text file is provided.\n try:\n fileName = easygui.fileopenbox(\"Enter a .txt file\",\n ... | [
"0.73346573",
"0.72095716",
"0.7022069",
"0.69514996",
"0.68601674",
"0.68402874",
"0.6771454",
"0.67425793",
"0.6699415",
"0.6610038",
"0.66019046",
"0.6577786",
"0.6573504",
"0.65729046",
"0.6548677",
"0.6542653",
"0.6541863",
"0.653708",
"0.6503757",
"0.65007627",
"0.64802... | 0.70722294 | 2 |
prints a list consisting of each element is a list of 2 itmes as (str,int) in a neat format [example list = [ ("abc",1),("efghij",20),......etc ] | def tabular_formatted_printing(data_list):
n = len(data_list)
max = 0
for i in range(0,n):
if int(len(data_list[i][0])) > max:
max = len(data_list[i][0])
for i in range(0,n):
if int(len(data_list[i][0])) < max:
space = max - len(data_list[i][0])
else:
space = 0
print(data_list[i][0]+space*' '+' : '+str(data_list[i][1]))
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_list(numbers):\n print(' '.join(map(str, numbers)))",
"def _list_to_printable(value):\n fixed_items = []\n for item in value:\n if isinstance(item, (int, float)):\n fixed_items.append(str(item))\n elif item == None:\n fixed_items.append(\"NULL\")\n eli... | [
"0.6564532",
"0.6426839",
"0.6420148",
"0.6390392",
"0.6295237",
"0.6276649",
"0.6256306",
"0.6188778",
"0.617754",
"0.61772645",
"0.6162995",
"0.61229706",
"0.61229706",
"0.6106786",
"0.60617495",
"0.60488445",
"0.6039565",
"0.60372084",
"0.6031298",
"0.6028703",
"0.6027985"... | 0.0 | -1 |
Running cost function (Lagrangian) | def lagr(self, x):
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_cost(AL, Y):\n pass",
"def compute_cost(AL, Y):\n pass",
"def compute_cost_derivative(AL, Y):\n pass",
"def compute_cost(AL, Y, parameters ,lambd):\n L = len(parameters) // 2\n m = Y.shape[1]\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\... | [
"0.6927716",
"0.6886076",
"0.6690253",
"0.65850383",
"0.6506424",
"0.6447081",
"0.6429702",
"0.63852924",
"0.63443947",
"0.6304937",
"0.626403",
"0.62328404",
"0.62026113",
"0.61965936",
"0.618344",
"0.6173027",
"0.6151762",
"0.61476064",
"0.6139949",
"0.61124724",
"0.6098959... | 0.0 | -1 |
Save data with games to file | async def save(self, res: dict):
self.___cache_data(res['games']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, game):\n try:\n with open(self.filename, mode='w+') as file:\n # First char in the file is the next player\n file.write(game.next_player)\n # Then the board as a string of 64 characters\n file.write(str(game.board))\n\n ... | [
"0.76108927",
"0.7576153",
"0.73735857",
"0.73119766",
"0.71675503",
"0.7154071",
"0.7152303",
"0.71430117",
"0.7106383",
"0.7105386",
"0.7067481",
"0.699197",
"0.6965784",
"0.69141096",
"0.6870099",
"0.68450946",
"0.67772365",
"0.6770521",
"0.6744814",
"0.6721609",
"0.670798... | 0.63036275 | 61 |
Get data from cached file and filter it | def __get_data(self, filters):
if not os.path.exists(CACHE_FILE):
raise DataNotScrappedError()
df = pd.read_csv(CACHE_FILE)
if not filters:
return list(df.T.to_dict().values())
filtered_df = df[df['name'] == filters][['category', 'name']]
return list(filtered_df.T.to_dict().values()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _retrieveCachedData(self):",
"def read_data_cache_file(self):\n with open(self.cache_filename, 'r') as json_data:\n return json.load(json_data)",
"def getData(self, local_cache):",
"def read_data_cache(self):\n if os.path.exists(self.cache_filename):\n return self.read... | [
"0.7370039",
"0.72422016",
"0.71613204",
"0.690746",
"0.68249017",
"0.67976505",
"0.6747037",
"0.66864574",
"0.6593007",
"0.6577908",
"0.6532192",
"0.6532192",
"0.65105075",
"0.6455156",
"0.64536875",
"0.64248145",
"0.64161235",
"0.6378454",
"0.63769585",
"0.6357792",
"0.6318... | 0.60076046 | 50 |
Get data from cached file | async def get(self, filters: dict = None):
res = self.__get_data(filters)
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _retrieveCachedData(self):",
"def getData(self, local_cache):",
"def read_data_cache_file(self):\n with open(self.cache_filename, 'r') as json_data:\n return json.load(json_data)",
"def GetFromCache(self, filename):\n return memcache.get('%s%s' % (self.CACHE_PREFIX, filename))",
"d... | [
"0.8146995",
"0.8129194",
"0.79291904",
"0.77733576",
"0.77733576",
"0.77026176",
"0.7592949",
"0.73793447",
"0.73505074",
"0.7287",
"0.7261666",
"0.7246066",
"0.7216164",
"0.71735895",
"0.71685135",
"0.71626484",
"0.7114864",
"0.7036473",
"0.7034909",
"0.70220995",
"0.700636... | 0.0 | -1 |
Grava objetos em formato texto no arquivo de Indices. | def gravarArquivoIndices(indices):
arq = open("arquivoIndices.txt", "w")
for i in indices.indices:
linha = i.codigo + "," + str(i.indice) + "," + str(i.excluido) + "\n"
arq.write(linha)
arq.close()
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def obj_index(self) -> str:\n return str(self._data[\"index\"])",
"def WriteIndexContent(indexList, formatindex, fpindex):#{{{\n if formatindex == FORMAT_TEXT:\n numRecord = len(indexList[0])\n idList = indexList[0]\n v1 = indexList[1]\n v2 = indexList[2]\n v3 = index... | [
"0.56216776",
"0.5584734",
"0.55089396",
"0.5442182",
"0.53701806",
"0.53672534",
"0.5365042",
"0.5347537",
"0.53458637",
"0.5334542",
"0.5304593",
"0.52780014",
"0.52368265",
"0.52331924",
"0.5230119",
"0.52129966",
"0.51751065",
"0.51676047",
"0.5156888",
"0.5112448",
"0.51... | 0.6343497 | 0 |
Grava objetos em formato texto no arquivo Extencao | def gravarArquivoExtencao(chave, nomeLivro, nomeAutor, mes, ano, extencao):
arq = open("arquivoExtencao.txt", "w")
linha = chave + nomeLivro + nomeAutor + mes + ano + "\n"
arq.seek(extencao, 0)
arq.write(linha)
arq.close()
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save2txt(obj, file: str):\n with open(file, \"w\") as f:\n print(obj, file=f)",
"def convert_txt_to_data():\n pass",
"def __str__(self):\n line = ''\n for linea in self.lista:\n for atributo in linea:\n if linea[atributo] != \"\":\n li... | [
"0.62898755",
"0.60060185",
"0.58115673",
"0.5791528",
"0.5781442",
"0.57075506",
"0.57075506",
"0.5631964",
"0.56186527",
"0.55803376",
"0.5567039",
"0.55542934",
"0.5503587",
"0.54971385",
"0.5476744",
"0.53883576",
"0.5385696",
"0.53556794",
"0.5348875",
"0.5341528",
"0.53... | 0.0 | -1 |
Grava objetos em formato texto no arquivo Extencao | def getArquivoExtencao(chave):
arq = open("arquivoExtencao.txt", "r")
linha = arq.readline()
achou = False
while linha and not achou:
if linha[0:7] == chave:
achou = True
linha = arq.readline()
arq.close()
return linha | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save2txt(obj, file: str):\n with open(file, \"w\") as f:\n print(obj, file=f)",
"def convert_txt_to_data():\n pass",
"def __str__(self):\n line = ''\n for linea in self.lista:\n for atributo in linea:\n if linea[atributo] != \"\":\n li... | [
"0.628988",
"0.60054374",
"0.58121145",
"0.5792043",
"0.57810664",
"0.57079685",
"0.57079685",
"0.5631726",
"0.5618268",
"0.5581328",
"0.5566677",
"0.55541193",
"0.55033374",
"0.54966205",
"0.5477309",
"0.53887737",
"0.538603",
"0.5356381",
"0.5347529",
"0.53421474",
"0.53346... | 0.0 | -1 |
Accepts any number of Pattern instances. | def __init__(self, *patterns):
# Validate.
for pattern in patterns:
if type(pattern) != models.patterns.Pattern:
raise TypeException("Session only initialized with Pattern instances.")
self.patterns = patterns | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_patterns(self, patterns: Iterable[AttributeRulerPatternType]) -> None:\n for p in patterns:\n self.add(**p) # type: ignore[arg-type]",
"def make_pattern_set(self):\n \n _pattern = []\n for x in range(1,9):\n _pattern.append(self.make_pattern())\n ... | [
"0.63439953",
"0.630216",
"0.6195141",
"0.6144406",
"0.6016073",
"0.5959742",
"0.58526075",
"0.58162165",
"0.5781618",
"0.5735671",
"0.57103336",
"0.566348",
"0.5650091",
"0.5646195",
"0.557469",
"0.5488463",
"0.5486494",
"0.5430798",
"0.53853893",
"0.536901",
"0.5356352",
... | 0.6190371 | 3 |
Return all row and column groups. | def get_regular_groups(self, grid, min=3):
row_groups = self._get_row_groups(grid.grid, models.patterns.RowPattern, min)
col_groups = self._get_row_groups(grid.grid.T, models.patterns.ColumnPattern, min)
return row_groups + col_groups | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def groups(self, *columns):\n # TODO: This really needs to just use Pandas.MultiIndex, stack(),\n # and pivot(). I just need to rework the FactorExprNode stuff\n # to produce a MultiIndex; then, this DataCube can just pass\n # in self._expr.\n raise NotImplementedError",
"def ... | [
"0.61957633",
"0.6163433",
"0.6040524",
"0.5894949",
"0.58843005",
"0.58239186",
"0.58054775",
"0.5755542",
"0.56944263",
"0.56619304",
"0.56394035",
"0.56309",
"0.56161165",
"0.56100893",
"0.55997294",
"0.55897653",
"0.5586745",
"0.5579677",
"0.55577207",
"0.55577207",
"0.55... | 0.68432385 | 0 |
Return groups with a min size that exist with grid on xaxis. | def _get_row_groups(self, array, pattern, min):
groups = []
for row, col in zip(array, xrange(len(array))):
start = 0
while start + min <= len(row):
size = 1
orb_type = type(row[start])
for cell in xrange(start + 1, len(row)):
if orb_type != type(row[cell]):
break
size += 1
start += 1
if size >= min:
groups.append(pattern(
orb_type, size, (col, start - size + 1)
))
start += 1
return groups | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_regular_groups(self, grid, min=3):\n row_groups = self._get_row_groups(grid.grid, models.patterns.RowPattern, min)\n col_groups = self._get_row_groups(grid.grid.T, models.patterns.ColumnPattern, min)\n return row_groups + col_groups",
"def remove_small_boxes(boxlist, min_size):\n ... | [
"0.5814698",
"0.56901836",
"0.56703305",
"0.5670049",
"0.55432373",
"0.55418265",
"0.55418265",
"0.5527169",
"0.5518961",
"0.5517546",
"0.55114937",
"0.55114937",
"0.5501184",
"0.5484425",
"0.54797846",
"0.5464368",
"0.54571414",
"0.53910476",
"0.5375301",
"0.5354567",
"0.534... | 0.48264712 | 91 |
Sends message to destination | async def connection_made(self, transport: asyncio.transports.BaseTransport) -> None:
self.transport = transport
transport.write(self.message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send(msg, dest=None):",
"def send_message(message, destination):\n\n #Your code here\n pass",
"def send(self):\n if(self.target):\n try:\n self.message = self.message +\"\\r\\n\"\n self.target[0].send(self.message)\n except socket.error, ... | [
"0.7889077",
"0.76901394",
"0.7472363",
"0.7467401",
"0.7311258",
"0.7185726",
"0.7074459",
"0.7047595",
"0.70432305",
"0.70432305",
"0.70432305",
"0.7038259",
"0.70371765",
"0.6928427",
"0.69204515",
"0.6901408",
"0.6896311",
"0.6889627",
"0.6871901",
"0.68246526",
"0.680819... | 0.0 | -1 |
Parses incoming dns message. | async def data_received(self, data: bytes) -> None:
self.response_message.set_result(data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dns_entry(self, msg):\n if msg['message'].find('Calling getaddrinfo') > -1:\n match = re.search(r'Calling getaddrinfo for host \\[(?P<host>[^\\]]+)\\]', msg['message'])\n if match:\n hostname = match.groupdict().get('host')\n if hostname not in self.dn... | [
"0.6813776",
"0.6387554",
"0.6330695",
"0.62516606",
"0.6083002",
"0.59635645",
"0.5952545",
"0.5765341",
"0.5750907",
"0.57202256",
"0.56227237",
"0.5602068",
"0.55890054",
"0.55267555",
"0.5508064",
"0.55026555",
"0.54993564",
"0.5461191",
"0.5436913",
"0.54354006",
"0.5335... | 0.0 | -1 |
Create or replace Secret and SecretACL | def create_or_replace_from_model(cls, secret, secret_acl,
user_ids=None, session=None):
secret.updated_at = timeutils.utcnow()
secret_acl.updated_at = timeutils.utcnow()
secret.save(session=session)
if secret_acl.id:
secret_acl.save(session=session)
else:
secret_acl.create(session=session)
cls._create_or_replace_acl_users(secret_acl=secret_acl,
user_ids=user_ids,
session=session) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_secret(secret_name, secret_value, environment):\n environment.add_cleanup(\n environment.cfy.secrets.delete,\n kwargs={\n 'secret_name': secret_name,\n },\n )\n environment.cfy.secrets.create(\n secret_name=secret_name,\n secret_value=secret_value,\... | [
"0.64323485",
"0.62295574",
"0.6069437",
"0.596446",
"0.5957099",
"0.59304917",
"0.5887804",
"0.58768106",
"0.5779729",
"0.577644",
"0.57579327",
"0.57563096",
"0.570285",
"0.5653871",
"0.56200135",
"0.56157786",
"0.56119484",
"0.55998737",
"0.5584007",
"0.5539168",
"0.553808... | 0.5757704 | 11 |
Create or replace acl_user | def _create_or_replace_acl_users(cls, secret_acl, user_ids, session=None):
if user_ids is None:
return
user_ids = set(user_ids)
now = timeutils.utcnow()
secret_acl.updated_at = now
for acl_user in secret_acl.acl_users:
if acl_user.user_id in user_ids: # input user_id already exists
acl_user.updated_at = now
acl_user.save(session=session)
user_ids.remove(acl_user.user_id)
else:
acl_user.delete(session=session)
for user_id in user_ids:
acl_user = secret_acl_user.SecretACLUser(acl_id=secret_acl.id,
user_id=user_id)
acl_user.create(session=session)
if secret_acl.id:
secret_acl.save(session=session)
else:
secret_acl.create(session=session) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_user(cls, user):\r\n pass",
"def set(isamAppliance, name, user_name, type='embedded_ldap', check_mode=False, force=False):\n new_user = True\n ret_obj = ibmsecurity.isam.base.management_authorization.role.get(isamAppliance, name)\n\n if (ret_obj['data']['users'] == None):\n ret_obj... | [
"0.6455713",
"0.6377649",
"0.63585895",
"0.6333561",
"0.62336445",
"0.61381245",
"0.6114977",
"0.6101846",
"0.60849553",
"0.60306436",
"0.6008215",
"0.6007202",
"0.5928761",
"0.59142447",
"0.5895722",
"0.5890398",
"0.5890398",
"0.5881839",
"0.5862956",
"0.5856963",
"0.5847015... | 0.6061465 | 9 |
Delete acl in Secret | def delete_acls_for_secret_model(cls, secret, session=None):
cls.db_repo.delete_acls_for_secret(secret, session) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_vault_delete_authorization_for_vault_section(self):\n pass",
"def delete_acl(self, sg):\n self.security_group_driver.delete_acl(sg)",
"def delete(key, **kwargs):\n cluster_call(\n \"secret_delete\",\n key=key,\n **kwargs,\n confirm=f\"Delete secret {key}\",... | [
"0.66316605",
"0.65926045",
"0.64347994",
"0.6348736",
"0.6199564",
"0.61836725",
"0.61462086",
"0.61307585",
"0.6130368",
"0.60911834",
"0.6086925",
"0.6073761",
"0.6018572",
"0.6013481",
"0.60084015",
"0.59860677",
"0.593387",
"0.58928955",
"0.58561933",
"0.5819227",
"0.578... | 0.6557337 | 2 |
Delete acl in a secret. | def delete_acls_for_secret(cls, secret, session=None):
session = cls.get_session(session=session)
for entity in secret.secret_acls:
entity.delete(session=session) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_acls_for_secret_model(cls, secret, session=None):\n cls.db_repo.delete_acls_for_secret(secret, session)",
"def delete_acl(self, sg):\n self.security_group_driver.delete_acl(sg)",
"def delete_secret_link(link_id):\n\n Secret_Link.objects.filter(link_id=link_id).delete()",
"def dele... | [
"0.7304661",
"0.7133021",
"0.6473207",
"0.6455759",
"0.6440277",
"0.6435884",
"0.64185977",
"0.6405398",
"0.63174623",
"0.6266833",
"0.6206975",
"0.6191693",
"0.61805665",
"0.6168148",
"0.6163188",
"0.60189515",
"0.59845203",
"0.5972625",
"0.59346336",
"0.5915101",
"0.5906380... | 0.72501093 | 1 |
Obtain basic information about onefs | def show(self, username, txn_id):
logger = get_task_logger(txn_id=txn_id, task_id=self.request.id, loglevel=const.VLAB_ONEFS_LOG_LEVEL.upper())
resp = {'content' : {}, 'error': None, 'params': {}}
logger.info('Task starting')
try:
info = vmware.show_onefs(username)
except ValueError as doh:
logger.error('Task failed: {}'.format(doh))
resp['error'] = '{}'.format(doh)
else:
logger.info('Task complete')
resp['content'] = info
return resp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getInfo():",
"def info() -> None:",
"def info(self):\n return self.nfo",
"def info(self):",
"def info(self):",
"def demo():\n logging.basicConfig(level=logging.INFO, format=\"%(message)s\")\n fcm = FMQLCacher(\"Caches\")\n fcm.setVista(\"CGVISTA\", \"http://vista.caregraf.org/fmqlEP\"... | [
"0.6832259",
"0.67963994",
"0.66478056",
"0.61971104",
"0.61971104",
"0.61895555",
"0.6114911",
"0.6114911",
"0.6095414",
"0.60491127",
"0.5942189",
"0.5878473",
"0.58726853",
"0.584561",
"0.5845232",
"0.58328277",
"0.58308643",
"0.58216065",
"0.58098024",
"0.5809369",
"0.580... | 0.0 | -1 |
Deploy a new OneFS node | def create(self, username, machine_name, image, front_end, back_end, ram, cpu_count, txn_id):
logger = get_task_logger(txn_id=txn_id, task_id=self.request.id, loglevel=const.VLAB_ONEFS_LOG_LEVEL.upper())
resp = {'content' : {}, 'error': None, 'params': {}}
logger.info('Task starting')
try:
resp['content'] = vmware.create_onefs(username, machine_name, image, front_end, back_end, ram, cpu_count, logger)
except ValueError as doh:
logger.error('Task failed: {}'.format(doh))
resp['error'] = '{}'.format(doh)
logger.info('Task complete')
return resp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deploy():",
"def deploy_node(self, node_name, node, node_folder, client):\n if client is None:\n client = self.CLIENT\n\n # Create specific command for input and output parameters\n param_i = [\"--i={}\".format(p) for p in node[\"to_set\"]]\n param_o = [\"--o={}\".forma... | [
"0.69264865",
"0.63039076",
"0.62826276",
"0.6249289",
"0.6248976",
"0.6238209",
"0.6202333",
"0.6194543",
"0.6194543",
"0.6194543",
"0.61874604",
"0.6165393",
"0.6107505",
"0.6099111",
"0.60960966",
"0.6072571",
"0.6064653",
"0.60304236",
"0.60209894",
"0.6007666",
"0.598098... | 0.5484384 | 66 |
Destroy a OneFS node | def delete(self, username, machine_name, txn_id):
logger = get_task_logger(txn_id=txn_id, task_id=self.request.id, loglevel=const.VLAB_ONEFS_LOG_LEVEL.upper())
resp = {'content' : {}, 'error': None, 'params': {}}
logger.info('Task starting')
try:
vmware.delete_onefs(username, machine_name, logger)
except ValueError as doh:
logger.error('Task failed: {}'.format(doh))
resp['error'] = '{}'.format(doh)
else:
logger.info('Task complete')
return resp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy_node(self):\n driver = self.driver\n driver.ex_detach_floating_ip_from_node(self.node, self.floating_ip)\n driver.destroy_node(self.node)\n sleep(15)\n for volume in self.volumes:\n driver.destroy_volume(volume)",
"def deletenode(self, node_p=None):\n ... | [
"0.74795836",
"0.7125707",
"0.70684725",
"0.6884586",
"0.6880332",
"0.674062",
"0.66680616",
"0.6622097",
"0.66166276",
"0.65986913",
"0.6577545",
"0.65129596",
"0.65098155",
"0.65094095",
"0.6506481",
"0.6490085",
"0.64562887",
"0.6453083",
"0.64295024",
"0.6426773",
"0.6406... | 0.0 | -1 |
Obtain the available OneFS images/versions that can be deployed | def image(self, txn_id):
logger = get_task_logger(txn_id=txn_id, task_id=self.request.id, loglevel=const.VLAB_ONEFS_LOG_LEVEL.upper())
resp = {'content' : {}, 'error': None, 'params': {}}
logger.info('Task starting')
resp['content'] = {'image': vmware.list_images()}
logger.info('Task complete')
return resp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_available_images():\n return AVAILABLE_IMAGES",
"def get_installed_images(self):\n raise NotImplementedError",
"def list_images(self):\n \n logging.debug(\"list_images entered for %s\" % self.machine_name) \n snapshots = cs.list_snapshots()\n res = []\n serv... | [
"0.69780606",
"0.6833153",
"0.6587997",
"0.6557733",
"0.63813823",
"0.63264614",
"0.62088",
"0.61655736",
"0.5964975",
"0.5890417",
"0.5876325",
"0.5871348",
"0.5833859",
"0.58310384",
"0.5792491",
"0.5789766",
"0.5733587",
"0.57318777",
"0.57247746",
"0.57242477",
"0.5707273... | 0.0 | -1 |
Turn a blank OneFS node into a usable device | def config(self, cluster_name, name, username, version, int_netmask, int_ip_low,
int_ip_high, ext_netmask, ext_ip_low, ext_ip_high, gateway, dns_servers,
encoding, sc_zonename, smartconnect_ip, join_cluster, compliance, txn_id):
logger = get_task_logger(txn_id=txn_id, task_id=self.request.id, loglevel=const.VLAB_ONEFS_LOG_LEVEL.upper())
resp = {'content' : {}, 'error': None, 'params': {}}
logger.info('Task starting')
nodes = vmware.show_onefs(username)
node = nodes.get(name, None)
if not node:
error = "No node named {} found".format(name)
resp['error'] = error
logger.error(error)
return resp
elif node['meta']['configured']:
error = "Cannot configure a node that's already configured"
resp['error'] = error
logger.error(error)
else:
# Lets set it up!
logger.info('Found node')
console_url = node['console']
if join_cluster:
logger.info('Joining node to cluster {}'.format(cluster_name))
setup_onefs.join_existing_cluster(console_url, cluster_name, compliance, logger)
else:
logger.info('Setting up new cluster named {}'.format(cluster_name))
setup_onefs.configure_new_cluster(version=version,
console_url=console_url,
cluster_name=cluster_name,
int_netmask=int_netmask,
int_ip_low=int_ip_low,
int_ip_high=int_ip_high,
ext_netmask=ext_netmask,
ext_ip_low=ext_ip_low,
ext_ip_high=ext_ip_high,
gateway=gateway,
dns_servers=dns_servers,
encoding=encoding,
sc_zonename=sc_zonename,
smartconnect_ip=smartconnect_ip,
compliance=compliance,
logger=logger)
node['meta']['configured'] = True
vmware.update_meta(username, name, node['meta'])
logger.info('Task complete')
return resp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addDevice(self, node, fullDeviceName, device):",
"def _get_device(node):\n\n vpp = VppPCIUtil(node)\n vpp.get_all_devices()\n\n # Save the device information\n node[\"devices\"] = {}\n node[\"devices\"][\"dpdk_devices\"] = vpp.get_dpdk_devices()\n node[\"devices\"][\... | [
"0.6119266",
"0.5911754",
"0.59111613",
"0.5813898",
"0.5722772",
"0.56492436",
"0.56458735",
"0.5626259",
"0.5560795",
"0.55487764",
"0.5547376",
"0.5536614",
"0.55227935",
"0.549715",
"0.545163",
"0.5447037",
"0.5447037",
"0.542734",
"0.5422956",
"0.54173166",
"0.54056215",... | 0.0 | -1 |
Change the network an OneFS node is connected to | def modify_network(self, username, machine_name, new_network, txn_id):
logger = get_task_logger(txn_id=txn_id, task_id=self.request.id, loglevel=const.VLAB_ONEFS_LOG_LEVEL.upper())
resp = {'content' : {}, 'error': None, 'params': {}}
logger.info('Task starting')
try:
vmware.update_network(username, machine_name, new_network)
except ValueError as doh:
logger.error('Task failed: {}'.format(doh))
resp['error'] = '{}'.format(doh)
logger.info('Task complete')
return resp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_target_network(self):\r\n self.send(self.server_conn, (sys._getframe().f_code.co_name, {}))",
"def set_network(self, network: str) -> None:\n return self.add_value(self._network_attribute, network)",
"def set_node(self, name, state):\n self.source_net.nodes[name] = state",
"de... | [
"0.6587989",
"0.63514805",
"0.63323206",
"0.61741155",
"0.61734724",
"0.6134296",
"0.6105218",
"0.6065056",
"0.60462487",
"0.59799916",
"0.5911158",
"0.5871496",
"0.583898",
"0.58377373",
"0.5814114",
"0.580636",
"0.5799185",
"0.5790336",
"0.5773519",
"0.57696205",
"0.5767448... | 0.5633962 | 35 |
Loads a checkpoint of a model, may be the model or the mean teacher model. Assumes the model has already been created, and the checkpoint exists. This does not set checkpoint epoch. This method should not be called externally. Use instead try_load_checkpoint_for_model or try_load_checkpoint_for_mean_teacher_model | def _load_checkpoint(cls, model: DeviceAwareModule, checkpoint_path: Path,
key_in_state_dict: str, use_gpu: bool) -> int:
logging.info(f"Loading checkpoint {checkpoint_path}")
checkpoint = ModelAndInfo.read_checkpoint(checkpoint_path, use_gpu)
try:
state_dict = checkpoint[key_in_state_dict]
except KeyError:
logging.error(f"Key {key_in_state_dict} not found in checkpoint")
return False
if isinstance(model, torch.nn.DataParallel):
result = model.module.load_state_dict(state_dict, strict=False)
else:
result = model.load_state_dict(state_dict, strict=False)
if result.missing_keys:
logging.warning(f"Missing keys in model checkpoint: {result.missing_keys}")
if result.unexpected_keys:
logging.warning(f"Unexpected keys in model checkpoint: {result.unexpected_keys}")
return checkpoint[ModelAndInfo.EPOCH_KEY] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_model(model, checkpoint_path: str): \r\n checkpoint = torch.load(checkpoint_path)\r\n model.load_state_dict(checkpoint['model'])\r\n epoch = checkpoint['epoch']\r\n print('Loaded model from {}, epoch {}'.format(checkpoint_path, epoch))",
"def load_checkpoint(tag, params, model):\r\n file... | [
"0.7765723",
"0.77516997",
"0.7738326",
"0.77286375",
"0.7725346",
"0.76465744",
"0.7636256",
"0.75987977",
"0.75818604",
"0.75716907",
"0.75123113",
"0.74969316",
"0.73805517",
"0.7359161",
"0.7350395",
"0.7348898",
"0.73487484",
"0.73225814",
"0.7317315",
"0.72933567",
"0.7... | 0.68640363 | 42 |
Updates a torch model so that input minibatches are parallelized across the batch dimension to utilise multiple gpus. If model parallel is set to True and execution is in test mode, then model is partitioned to perform full volume inference. This assumes the model has been created, that the optimizer has not yet been created, and the the model has not been adjusted twice. This method should not be called externally. Use instead adjust_model_for_gpus or adjust_mean_teacher_model_for_gpus | def _adjust_for_gpus(cls, model: DeviceAwareModule, config: ModelConfigBase,
model_execution_mode: ModelExecutionMode) -> DeviceAwareModule:
if config.use_gpu:
model = model.cuda()
logging.info("Adjusting the model to use mixed precision training.")
# If model parallel is set to True, then partition the network across all available gpus.
if config.use_model_parallel:
devices = config.get_cuda_devices()
assert devices is not None # for mypy
model.partition_model(devices=devices) # type: ignore
else:
logging.info("Making no adjustments to the model because no GPU was found.")
# Update model related config attributes (After Model Parallel Activated)
config.adjust_after_mixed_precision_and_parallel(model)
# DataParallel enables running the model with multiple gpus by splitting samples across GPUs
# If the model is used in training mode, data parallel is activated by default.
# Similarly, if model parallel is not activated, data parallel is used as a backup option
use_data_parallel = (model_execution_mode == ModelExecutionMode.TRAIN) or (not config.use_model_parallel)
if config.use_gpu and use_data_parallel:
logging.info("Adjusting the model to use DataParallel")
# Move all layers to the default GPU before activating data parallel.
# This needs to happen even though we put the model to the GPU at the beginning of the method,
# but we may have spread it across multiple GPUs later.
model = model.cuda()
model = DataParallelModel(model, device_ids=config.get_cuda_devices())
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_model_parallel(self, global_rank: int, world_size: int) -> None:\n app_state = AppState()\n\n # we initialize megatron-lm model parallel and data parallel groups\n # after initializing DDP with PTL.\n if app_state.model_parallel_size is not None:\n # destroy groups i... | [
"0.5936191",
"0.56602675",
"0.56224686",
"0.5621566",
"0.55595684",
"0.54760945",
"0.54551095",
"0.54427326",
"0.54231954",
"0.54035556",
"0.5396976",
"0.53836715",
"0.5365184",
"0.53514045",
"0.5305904",
"0.5280321",
"0.5267586",
"0.5260385",
"0.525179",
"0.5249681",
"0.5188... | 0.70964164 | 0 |
Creates a model (with temperature scaling) according to the config given. | def create_model(self) -> None:
self._model = create_model_with_temperature_scaling(self.config) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_model_with_temperature_scaling(config: ModelConfigBase) -> Any:\n # wrap the model around a temperature scaling model if required\n model = config.create_model()\n if isinstance(config, SequenceModelBase) and config.temperature_scaling_config:\n model = ModelWithTemperature(model, config... | [
"0.8444309",
"0.65563035",
"0.637411",
"0.6288527",
"0.62518233",
"0.622743",
"0.622743",
"0.6217139",
"0.6207316",
"0.6149929",
"0.6077935",
"0.6031471",
"0.6030025",
"0.6021649",
"0.5992696",
"0.59753346",
"0.5956578",
"0.5916777",
"0.5907874",
"0.5907593",
"0.58919555",
... | 0.8335938 | 1 |
Loads a checkpoint of a model. The provided model checkpoint must match the stored model. | def try_load_checkpoint_for_model(self) -> bool:
if self._model is None:
raise ValueError("Model must be created before it can be adjusted.")
if not self.checkpoint_path:
raise ValueError("No checkpoint provided")
if not self.checkpoint_path.is_file():
logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')
return False
epoch = ModelAndInfo._load_checkpoint(model=self._model,
checkpoint_path=self.checkpoint_path,
key_in_state_dict=ModelAndInfo.MODEL_STATE_DICT_KEY,
use_gpu=self.config.use_gpu)
logging.info(f"Loaded model from checkpoint (epoch: {epoch})")
self.checkpoint_epoch = epoch
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_model(model, checkpoint_path: str): \r\n checkpoint = torch.load(checkpoint_path)\r\n model.load_state_dict(checkpoint['model'])\r\n epoch = checkpoint['epoch']\r\n print('Loaded model from {}, epoch {}'.format(checkpoint_path, epoch))",
"def load_checkpoint(self, session, model_dir):\n ... | [
"0.8315826",
"0.8164179",
"0.8112332",
"0.8067118",
"0.8025133",
"0.80095977",
"0.79719204",
"0.792332",
"0.78759766",
"0.7870545",
"0.7857625",
"0.78201485",
"0.777726",
"0.76251996",
"0.7613241",
"0.76099503",
"0.7592557",
"0.75774544",
"0.75367856",
"0.75308794",
"0.751686... | 0.7488327 | 21 |
Updates the torch model so that input minibatches are parallelized across the batch dimension to utilise multiple gpus. If model parallel is set to True and execution is in test mode, then model is partitioned to perform full volume inference. | def adjust_model_for_gpus(self) -> None:
if self._model is None:
raise ValueError("Model must be created before it can be adjusted.")
# Adjusting twice causes an error.
if self.is_model_adjusted:
logging.debug("model_and_info.is_model_adjusted is already True")
if self._optimizer:
raise ValueError("Create an optimizer only after creating and adjusting the model.")
self._model = ModelAndInfo._adjust_for_gpus(model=self._model,
config=self.config,
model_execution_mode=self.model_execution_mode)
self.is_model_adjusted = True
logging.debug("model_and_info.is_model_adjusted set to True") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _adjust_for_gpus(cls, model: DeviceAwareModule, config: ModelConfigBase,\n model_execution_mode: ModelExecutionMode) -> DeviceAwareModule:\n if config.use_gpu:\n model = model.cuda()\n logging.info(\"Adjusting the model to use mixed precision training.\")\n ... | [
"0.63490736",
"0.6151383",
"0.6141063",
"0.610996",
"0.6103388",
"0.60952216",
"0.59621423",
"0.5786127",
"0.5765342",
"0.5759161",
"0.57430667",
"0.56928396",
"0.56227285",
"0.55986506",
"0.55617046",
"0.5559076",
"0.55540496",
"0.54423124",
"0.5432483",
"0.5429761",
"0.5385... | 0.0 | -1 |
Generates the model summary, which is required for model partitioning across GPUs, and then moves the model to GPU with data parallel/model parallel by calling adjust_model_for_gpus. | def create_summary_and_adjust_model_for_gpus(self) -> None:
if self._model is None:
raise ValueError("Model must be created before it can be adjusted.")
if self.config.is_segmentation_model:
summary_for_segmentation_models(self.config, self._model)
# Prepare for mixed precision training and data parallelization (no-op if already done).
# This relies on the information generated in the model summary.
self.adjust_model_for_gpus() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_and_print_model_summary(config: ModelConfigBase, model: DeviceAwareModule) -> None:\n random_state = RandomStateSnapshot.snapshot_random_state()\n # There appears to be a bug in apex, where previous use (in training for example) causes problems\n # when another model is later built on the CPU... | [
"0.7002343",
"0.62532896",
"0.62355524",
"0.6192523",
"0.61289847",
"0.6088246",
"0.59602416",
"0.5950651",
"0.59498066",
"0.5881187",
"0.588016",
"0.5873111",
"0.58373106",
"0.5834648",
"0.58186084",
"0.58035755",
"0.57857174",
"0.57534796",
"0.5750009",
"0.5738947",
"0.5732... | 0.7819205 | 0 |
Creates a model as per the config, and loads the parameters from the given checkpoint path. Also updates the checkpoint_epoch. | def try_create_model_and_load_from_checkpoint(self) -> bool:
self.create_model()
if self.checkpoint_path:
# Load the stored model. If there is no checkpoint present, return immediately.
return self.try_load_checkpoint_for_model()
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_checkpoint(model_config, path):\n model = models.VisionTransformer(num_classes=1, **model_config)\n variables = model.init(\n jax.random.PRNGKey(0),\n jnp.ones([1, 16, 16, 3], jnp.float32),\n train=False,\n )\n _save(variables['params'], path)",
"def load_model(self, checkpoint):\n ... | [
"0.771995",
"0.75882643",
"0.7439317",
"0.7204472",
"0.71614414",
"0.71529615",
"0.71529615",
"0.70953584",
"0.70633674",
"0.7042233",
"0.7033582",
"0.69744486",
"0.6970394",
"0.6955097",
"0.6915084",
"0.6887449",
"0.6820261",
"0.6804254",
"0.679512",
"0.677149",
"0.67633355"... | 0.6709257 | 23 |
Creates a model as per the config, and loads the parameters from the given checkpoint path. The model is then adjusted for data parallelism and mixed precision. Also updates the checkpoint_epoch. | def try_create_model_load_from_checkpoint_and_adjust(self) -> bool:
success = self.try_create_model_and_load_from_checkpoint()
self.create_summary_and_adjust_model_for_gpus()
return success | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self, model_path):\n # TODO: include new params based on ConfigEnum\n checkpoint = torch.load(model_path)\n\n self.image_size = checkpoint['image_size']\n self.device = checkpoint['device']\n self.fp16 = checkpoint['fp16']\n self.accumulate_grad_steps = checkpoint... | [
"0.77299833",
"0.74241644",
"0.7334485",
"0.7309532",
"0.71466875",
"0.7120709",
"0.7097819",
"0.70120436",
"0.6995636",
"0.69388175",
"0.69167244",
"0.69100595",
"0.69032747",
"0.6854969",
"0.68546087",
"0.68304265",
"0.6785825",
"0.67773795",
"0.6773737",
"0.67481923",
"0.6... | 0.6487272 | 47 |
Creates a model (with temperature scaling) according to the config given. | def create_mean_teacher_model(self) -> None:
self._mean_teacher_model = create_model_with_temperature_scaling(self.config) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_model_with_temperature_scaling(config: ModelConfigBase) -> Any:\n # wrap the model around a temperature scaling model if required\n model = config.create_model()\n if isinstance(config, SequenceModelBase) and config.temperature_scaling_config:\n model = ModelWithTemperature(model, config... | [
"0.84457386",
"0.83382916",
"0.65599996",
"0.6377564",
"0.6291746",
"0.62521607",
"0.6228496",
"0.6228496",
"0.62193686",
"0.62099886",
"0.6151095",
"0.60817146",
"0.60338646",
"0.60337704",
"0.60258543",
"0.5996558",
"0.5979533",
"0.5957634",
"0.5921604",
"0.59115314",
"0.59... | 0.57454526 | 34 |
Loads a checkpoint of a model. The provided model checkpoint must match the stored model. | def try_load_checkpoint_for_mean_teacher_model(self) -> bool:
if self._mean_teacher_model is None:
raise ValueError("Mean teacher model must be created before it can be adjusted.")
if not self.checkpoint_path:
raise ValueError("No checkpoint provided")
if not self.checkpoint_path.is_file():
logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')
return False
epoch = ModelAndInfo._load_checkpoint(model=self._mean_teacher_model,
checkpoint_path=self.checkpoint_path,
key_in_state_dict=ModelAndInfo.MEAN_TEACHER_STATE_DICT_KEY,
use_gpu=self.config.use_gpu)
logging.info(f"Loaded mean teacher model from checkpoint (epoch: {epoch})")
self.checkpoint_epoch = epoch
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_model(model, checkpoint_path: str): \r\n checkpoint = torch.load(checkpoint_path)\r\n model.load_state_dict(checkpoint['model'])\r\n epoch = checkpoint['epoch']\r\n print('Loaded model from {}, epoch {}'.format(checkpoint_path, epoch))",
"def load_checkpoint(self, session, model_dir):\n ... | [
"0.8315387",
"0.81653464",
"0.8112465",
"0.80683154",
"0.8026479",
"0.80094665",
"0.79719937",
"0.7923825",
"0.7876365",
"0.7869957",
"0.78584534",
"0.782106",
"0.7777016",
"0.7624399",
"0.7612878",
"0.76103896",
"0.7592807",
"0.7576732",
"0.7537933",
"0.75310373",
"0.751883"... | 0.0 | -1 |
Updates the torch model so that input minibatches are parallelized across the batch dimension to utilise multiple gpus. If model parallel is set to True and execution is in test mode, then model is partitioned to perform full volume inference. | def adjust_mean_teacher_model_for_gpus(self) -> None:
if self._mean_teacher_model is None:
raise ValueError("Mean teacher model must be created before it can be adjusted.")
# Adjusting twice causes an error.
if self.is_mean_teacher_model_adjusted:
logging.debug("model_and_info.is_mean_teacher_model_adjusted is already True")
self._mean_teacher_model = ModelAndInfo._adjust_for_gpus(model=self._mean_teacher_model,
config=self.config,
model_execution_mode=self.model_execution_mode)
self.is_mean_teacher_model_adjusted = True
logging.debug("model_and_info.is_mean_teacher_model_adjusted set to True") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _adjust_for_gpus(cls, model: DeviceAwareModule, config: ModelConfigBase,\n model_execution_mode: ModelExecutionMode) -> DeviceAwareModule:\n if config.use_gpu:\n model = model.cuda()\n logging.info(\"Adjusting the model to use mixed precision training.\")\n ... | [
"0.63509315",
"0.6149969",
"0.61396825",
"0.6108458",
"0.61034065",
"0.60946226",
"0.59626156",
"0.57862693",
"0.57671374",
"0.5759996",
"0.57448643",
"0.5693965",
"0.56239045",
"0.5599338",
"0.55595565",
"0.55579144",
"0.55540186",
"0.5442606",
"0.54349464",
"0.5431222",
"0.... | 0.0 | -1 |
Generates the model summary, which is required for model partitioning across GPUs, and then moves the model to GPU with data parallel/model parallel by calling adjust_model_for_gpus. | def create_summary_and_adjust_mean_teacher_model_for_gpus(self) -> None:
if self._mean_teacher_model is None:
raise ValueError("Mean teacher model must be created before it can be adjusted.")
if self.config.is_segmentation_model:
summary_for_segmentation_models(self.config, self._mean_teacher_model)
# Prepare for mixed precision training and data parallelization (no-op if already done).
# This relies on the information generated in the model summary.
self.adjust_mean_teacher_model_for_gpus() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_summary_and_adjust_model_for_gpus(self) -> None:\n if self._model is None:\n raise ValueError(\"Model must be created before it can be adjusted.\")\n\n if self.config.is_segmentation_model:\n summary_for_segmentation_models(self.config, self._model)\n # Prepare... | [
"0.78193945",
"0.70014805",
"0.6252593",
"0.6235304",
"0.61942273",
"0.6128506",
"0.608759",
"0.5960813",
"0.59513026",
"0.59509206",
"0.58809274",
"0.58801025",
"0.5874364",
"0.5837946",
"0.58353555",
"0.5803747",
"0.57844466",
"0.5753908",
"0.5749925",
"0.57394",
"0.5733452... | 0.5817216 | 15 |
Creates a model as per the config, and loads the parameters from the given checkpoint path. Also updates the checkpoint_epoch. | def try_create_mean_teacher_model_and_load_from_checkpoint(self) -> bool:
self.create_mean_teacher_model()
if self.checkpoint_path:
# Load the stored model. If there is no checkpoint present, return immediately.
return self.try_load_checkpoint_for_mean_teacher_model()
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_checkpoint(model_config, path):\n model = models.VisionTransformer(num_classes=1, **model_config)\n variables = model.init(\n jax.random.PRNGKey(0),\n jnp.ones([1, 16, 16, 3], jnp.float32),\n train=False,\n )\n _save(variables['params'], path)",
"def load_model(self, checkpoint):\n ... | [
"0.77202636",
"0.7588646",
"0.7440869",
"0.7204906",
"0.71627265",
"0.7153112",
"0.7153112",
"0.7096752",
"0.7063371",
"0.7042817",
"0.7034828",
"0.6975058",
"0.69707805",
"0.69557154",
"0.69152653",
"0.6887786",
"0.6820848",
"0.68042725",
"0.67946786",
"0.6771584",
"0.676246... | 0.0 | -1 |
Creates a model as per the config, and loads the parameters from the given checkpoint path. The model is then adjusted for data parallelism and mixed precision. Also updates the checkpoint_epoch. | def try_create_mean_teacher_model_load_from_checkpoint_and_adjust(self) -> bool:
success = self.try_create_mean_teacher_model_and_load_from_checkpoint()
self.create_summary_and_adjust_mean_teacher_model_for_gpus()
return success | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self, model_path):\n # TODO: include new params based on ConfigEnum\n checkpoint = torch.load(model_path)\n\n self.image_size = checkpoint['image_size']\n self.device = checkpoint['device']\n self.fp16 = checkpoint['fp16']\n self.accumulate_grad_steps = checkpoint... | [
"0.77288234",
"0.7422351",
"0.73331386",
"0.7309896",
"0.7146994",
"0.7120653",
"0.709593",
"0.70095086",
"0.6994309",
"0.6936953",
"0.6916758",
"0.6907432",
"0.6901133",
"0.685239",
"0.6851834",
"0.682932",
"0.6783703",
"0.6779041",
"0.6770681",
"0.6748651",
"0.6746794",
"... | 0.0 | -1 |
Creates a torch optimizer for the given model, and stores it as an instance variable in the current object. | def create_optimizer(self) -> None:
# Make sure model is created before we create optimizer
if self._model is None:
raise ValueError("Model checkpoint must be created before optimizer checkpoint can be loaded.")
# Select optimizer type
if self.config.optimizer_type in [OptimizerType.Adam, OptimizerType.AMSGrad]:
self._optimizer = torch.optim.Adam(self._model.parameters(), self.config.l_rate,
self.config.adam_betas, self.config.opt_eps, self.config.weight_decay,
amsgrad=self.config.optimizer_type == OptimizerType.AMSGrad)
elif self.config.optimizer_type == OptimizerType.SGD:
self._optimizer = torch.optim.SGD(self._model.parameters(), self.config.l_rate, self.config.momentum,
weight_decay=self.config.weight_decay)
elif self.config.optimizer_type == OptimizerType.RMSprop:
self._optimizer = RMSprop(self._model.parameters(), self.config.l_rate, self.config.rms_alpha,
self.config.opt_eps,
self.config.weight_decay, self.config.momentum)
else:
raise NotImplementedError(f"Optimizer type {self.config.optimizer_type.value} is not implemented") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimizer(self, model: nn.Module) -> torch.optim.Optimizer: # type: ignore\n pass",
"def build_optimizer(model: nn.Module, args: Namespace) -> Optimizer:\n params = [{'params': model.parameters(), 'lr': args.init_lr, 'weight_decay': 0}]\n\n return Adam(params)",
"def get_optimizer(args, model... | [
"0.75656193",
"0.7248476",
"0.7094529",
"0.70669323",
"0.6984369",
"0.68603814",
"0.67578644",
"0.66976243",
"0.6690973",
"0.66653234",
"0.66625184",
"0.66552",
"0.6637654",
"0.66292614",
"0.6535859",
"0.65118015",
"0.6485002",
"0.6414784",
"0.6320487",
"0.6311424",
"0.630625... | 0.70478994 | 4 |
Loads a checkpoint of an optimizer. | def try_load_checkpoint_for_optimizer(self) -> bool:
if self._optimizer is None:
raise ValueError("Optimizer must be created before optimizer checkpoint can be loaded.")
if not self.checkpoint_path:
logging.warning("No checkpoint path provided.")
return False
if not self.checkpoint_path.is_file():
logging.warning(f'No checkpoint found at {self.checkpoint_path} current working dir {os.getcwd()}')
return False
logging.info(f"Loading checkpoint {self.checkpoint_path}")
checkpoint = ModelAndInfo.read_checkpoint(self.checkpoint_path, self.config.use_gpu)
try:
state_dict = checkpoint[ModelAndInfo.OPTIMIZER_STATE_DICT_KEY]
except KeyError:
logging.error(f"Key {ModelAndInfo.OPTIMIZER_STATE_DICT_KEY} not found in checkpoint")
return False
self._optimizer.load_state_dict(state_dict)
logging.info(f"Loaded optimizer from checkpoint (epoch: {checkpoint[ModelAndInfo.EPOCH_KEY]})")
self.checkpoint_epoch = checkpoint[ModelAndInfo.EPOCH_KEY]
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\n print(\"Load checkpoint from: {}\".format(path))\n state_dict, optimizer_state = _load(path)\n\n model.load_dict(state_dict)\n if not reset_optimizer and optimizer is not None:\n if optimizer_state is not None:\n ... | [
"0.83664644",
"0.80974585",
"0.80771816",
"0.80259275",
"0.7999482",
"0.79903316",
"0.7857532",
"0.7640271",
"0.75701135",
"0.748829",
"0.7443241",
"0.74228936",
"0.7389801",
"0.7375046",
"0.7372049",
"0.7315069",
"0.7312009",
"0.72855306",
"0.725681",
"0.7247519",
"0.7220198... | 0.7403394 | 12 |
Creates an optimizer and loads its state from a checkpoint. | def try_create_optimizer_and_load_from_checkpoint(self) -> bool:
self.create_optimizer()
if self.checkpoint_path:
return self.try_load_checkpoint_for_optimizer()
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\n self.model.load_state_dict(checkpoint[\"model_state_dict\"])\n self.optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n return self",
"def create_optimizer(self) -> None:\n # Make sure model is created befo... | [
"0.7107619",
"0.70649505",
"0.7064646",
"0.69969",
"0.6977983",
"0.6892563",
"0.6793151",
"0.67687976",
"0.673699",
"0.6716268",
"0.65814966",
"0.650589",
"0.64456534",
"0.64456534",
"0.6368876",
"0.632732",
"0.6312547",
"0.6301847",
"0.62795025",
"0.6267788",
"0.623797",
"... | 0.71238905 | 0 |
Saves a checkpoint of the current model and optimizer_type parameters in the specified folder and uploads it to the output blob storage of the current run context. The checkpoint's name for epoch 123 would be 123_checkpoint.pth.tar. | def save_checkpoint(self, epoch: int) -> Path:
logging.getLogger().disabled = True
model_state_dict = self.model.module.state_dict() \
if isinstance(self.model, torch.nn.DataParallel) else self.model.state_dict()
checkpoint_file_path = self.config.get_path_to_checkpoint(epoch)
checkpoint_file_path.parent.mkdir(exist_ok=True, parents=True)
info_to_store = {
ModelAndInfo.EPOCH_KEY: epoch,
ModelAndInfo.MODEL_STATE_DICT_KEY: model_state_dict,
ModelAndInfo.OPTIMIZER_STATE_DICT_KEY: self.optimizer.state_dict()
}
if self.config.compute_mean_teacher_model:
assert self.mean_teacher_model is not None # for mypy, getter has this built in
mean_teacher_model_state_dict = self.mean_teacher_model.module.state_dict() \
if isinstance(self.mean_teacher_model, torch.nn.DataParallel) \
else self.mean_teacher_model.state_dict()
info_to_store[ModelAndInfo.MEAN_TEACHER_STATE_DICT_KEY] = mean_teacher_model_state_dict
torch.save(info_to_store, checkpoint_file_path)
logging.getLogger().disabled = False
logging.info(f"Saved model checkpoint for epoch {epoch} to {checkpoint_file_path}")
return checkpoint_file_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _save_checkpoint(checkpoint, model_dir, checkpoint_prefix):\n\n checkpoint_path = os.path.join(model_dir, checkpoint_prefix)\n saved_path = checkpoint.save(checkpoint_path)\n logging.info('Saving model as TF checkpoint: %s', saved_path)\n return",
"def save_checkpoint(checkpoint_dir, epoch, iteration, sa... | [
"0.73279613",
"0.7212068",
"0.7110705",
"0.70985615",
"0.7074814",
"0.7049468",
"0.7041478",
"0.7008442",
"0.7005684",
"0.6975668",
"0.6948612",
"0.6930357",
"0.69280964",
"0.68722343",
"0.6871008",
"0.686374",
"0.6840294",
"0.67784363",
"0.6768815",
"0.6761419",
"0.6749226",... | 0.7023109 | 7 |
Initialize the weights of a Pytorch module. | def init_weights(m: Union[torch.nn.Conv3d, torch.nn.BatchNorm3d]) -> None:
import torch
if isinstance(m, torch.nn.Conv3d):
torch.nn.init.normal_(m.weight, 0, 0.01)
elif isinstance(m, torch.nn.BatchNorm3d):
torch.nn.init.constant_(m.weight, 1)
torch.nn.init.constant_(m.bias, 0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_weights(module: nn.Module, name: str, head_bias: float = 0., flax=False):\n if isinstance(module, nn.Linear):\n if name.startswith('head'):\n nn.init.zeros_(module.weight)\n nn.init.constant_(module.bias, head_bias)\n else:\n if flax:\n # F... | [
"0.77734",
"0.7753587",
"0.76126516",
"0.76039255",
"0.75937414",
"0.7557966",
"0.75483835",
"0.75483835",
"0.75483835",
"0.7541337",
"0.75397253",
"0.7527526",
"0.74981326",
"0.7479258",
"0.7456155",
"0.74487233",
"0.74385613",
"0.74289656",
"0.74223495",
"0.74188006",
"0.73... | 0.0 | -1 |
Generates a human readable summary of the present segmentation model, writes it to logging.info, and stores the ModelSummary object inside the argument `model`. | def summary_for_segmentation_models(config: ModelConfigBase, model: DeviceAwareModule) -> None:
assert isinstance(model, BaseModel)
crop_size = config.crop_size
if isinstance(crop_size, int):
crop_size = (crop_size, crop_size, crop_size)
try:
model.generate_model_summary(crop_size, log_summaries_to_files=config.log_summaries_to_files)
except AttributeError as e:
logging.warning(f"summary_for_segmentation_models failed with exception {e}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_and_print_model_summary(config: ModelConfigBase, model: DeviceAwareModule) -> None:\n random_state = RandomStateSnapshot.snapshot_random_state()\n # There appears to be a bug in apex, where previous use (in training for example) causes problems\n # when another model is later built on the CPU... | [
"0.73806274",
"0.7147296",
"0.6999165",
"0.6930897",
"0.68741435",
"0.6732777",
"0.67200786",
"0.6702313",
"0.6616318",
"0.65155643",
"0.6488972",
"0.6480176",
"0.6442557",
"0.64185977",
"0.6416413",
"0.6397906",
"0.6342395",
"0.63167113",
"0.63136315",
"0.6211133",
"0.620451... | 0.7225569 | 1 |
Writes a human readable summary of the present model to logging.info, and logs the number of trainable parameters to AzureML. | def generate_and_print_model_summary(config: ModelConfigBase, model: DeviceAwareModule) -> None:
random_state = RandomStateSnapshot.snapshot_random_state()
# There appears to be a bug in apex, where previous use (in training for example) causes problems
# when another model is later built on the CPU (for example, before loading from a checkpoint)
# https://github.com/NVIDIA/apex/issues/694
# Hence, move the model to the GPU before doing model summary.
if config.use_gpu:
model = model.cuda()
if isinstance(config, ScalarModelBase):
# To generate the model summary, read the first item of the dataset. Then use the model's own
# get_model_input function to convert the dataset item to input tensors, and feed them through the model.
train_dataset = config.get_torch_dataset_for_inference(ModelExecutionMode.TRAIN)
train_item_0 = next(iter(train_dataset.as_data_loader(shuffle=False, batch_size=1, num_dataload_workers=0)))
model_inputs = get_scalar_model_inputs_and_labels(config, model, train_item_0).model_inputs
# The model inputs may already be converted to float16, assuming that we would do mixed precision.
# However, the model is not yet converted to float16 when this function is called, hence convert back to float32
summary = ModelSummary(model)
summary.generate_summary(input_tensors=model_inputs, log_summaries_to_files=config.log_summaries_to_files)
elif config.is_segmentation_model:
summary_for_segmentation_models(config, model)
assert model.summarizer
summary = model.summarizer # type: ignore
else:
raise ValueError("Don't know how to generate a summary for this type of model?")
RUN_CONTEXT.log(LoggingColumns.NumTrainableParameters, summary.n_trainable_params)
random_state.restore_random_state() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def summary(self):\n\n self.model.summary(print_fn=lambda x: logging.info(x))",
"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(\"=\"... | [
"0.7465972",
"0.73062223",
"0.68315184",
"0.6818728",
"0.67563677",
"0.67499065",
"0.673236",
"0.6722741",
"0.66750515",
"0.6649921",
"0.6504973",
"0.64990056",
"0.64763284",
"0.64610624",
"0.64330405",
"0.64009935",
"0.63829356",
"0.6330708",
"0.62939197",
"0.62824273",
"0.6... | 0.60460424 | 30 |
Create a model with temperature scaling by wrapping the result of config.create_model with ModelWithTemperature, if temperature scaling config has been provided, otherwise return the result of config.create_model | def create_model_with_temperature_scaling(config: ModelConfigBase) -> Any:
# wrap the model around a temperature scaling model if required
model = config.create_model()
if isinstance(config, SequenceModelBase) and config.temperature_scaling_config:
model = ModelWithTemperature(model, config.temperature_scaling_config)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_model(self) -> None:\n self._model = create_model_with_temperature_scaling(self.config)",
"def do_create_model(**kwargs):\n model_params = {\n 'name': kwargs['dag_run'].conf.get('model_name'),\n 'description': 'A custom DNN regressor model',\n 'regions': [REGION]\n }\n\n ... | [
"0.73296446",
"0.57077694",
"0.570612",
"0.57056636",
"0.56610817",
"0.55574673",
"0.54785675",
"0.5419638",
"0.53965676",
"0.53905576",
"0.538604",
"0.538604",
"0.5313637",
"0.52842414",
"0.52818054",
"0.5228253",
"0.5218954",
"0.5209238",
"0.52031755",
"0.5201383",
"0.51910... | 0.8471851 | 0 |
Initialize your data structure here. | def __init__(self):
self.buckets = collections.defaultdict(list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__... | [
"0.7765608",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7595176",
"0.75853467",
"0.7558298",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.74971247",
"0.74971247",
"0.7478105",
"0.7477832",
"0.7477832",
"0.7477832",
... | 0.0 | -1 |
Build a dictionary through a list of words | def buildDict(self, words: List[str]) -> None:
for word in words:
self.buckets[len(word)].append(word) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_dict(word_list):\r\n\r\n # initialize a dictonary\r\n d = dict()\r\n\r\n # iterate through the word_list, mapping sorted letters to word\r\n for i in word_list:\r\n\r\n # key - sorted letters in the word\r\n # how to sort ? --> convert to list, then sort. Finally join the sorted... | [
"0.7771935",
"0.7714796",
"0.76650697",
"0.75896126",
"0.7402118",
"0.7371921",
"0.7257023",
"0.724838",
"0.72190464",
"0.71511894",
"0.7121465",
"0.70906883",
"0.70329714",
"0.69910663",
"0.6939837",
"0.6926235",
"0.69013107",
"0.68620795",
"0.68157786",
"0.6809816",
"0.6763... | 0.75077 | 4 |
Returns if there is any word in the trie that equals to the given word after modifying exactly one character | def search(self, word: str) -> bool:
# # for candidate in self.buckets[len(word)]:
# # for a, b in zip(word, candidate):
# # result = any(sum(a!=b))
return any(sum(a!=b for a, b in zip(word, candidate)) == 1
for candidate in self.buckets[len(word)])
#
# for candidate in self.buckets[len(word)]:
# sum = 0
# for a, b in zip(word, candidate):
# sum += (a!=b)
# if sum == 0:
# return True
# return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_word(trie, string: str) -> bool:\n return any(w == string for w in trie)",
"def search(self, word):\n curr = self.trie\n for i, ch in enumerate(word):\n curr = curr.get(ch, {})\n if curr:\n continue\n else:\n break\n \n... | [
"0.7898829",
"0.77123356",
"0.76817137",
"0.7651471",
"0.74973875",
"0.7494274",
"0.7490946",
"0.7471417",
"0.7440383",
"0.7440078",
"0.74153924",
"0.74125475",
"0.73968333",
"0.7382937",
"0.73649126",
"0.7333139",
"0.73310703",
"0.7293905",
"0.729297",
"0.72762936",
"0.72757... | 0.664082 | 86 |
Load twine from a .json filename, filelike or a json string and validates twine contents. | def _load_twine(self, source=None):
if source is None:
# If loading an unspecified twine, return an empty one rather than raising error (like in _load_data())
raw_twine = {}
logger.warning("No twine source specified. Loading empty twine.")
else:
raw_twine = self._load_json("twine", source, allowed_kinds=("file-like", "filename", "string", "object"))
self._validate_against_schema("twine", raw_twine)
self._validate_twine_version(twine_file_twined_version=raw_twine.get("twined_version", None))
return raw_twine | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_tweets(filename):\n\n try:\n with open(filename, 'r') as f:\n data = json.loads(f.read())\n except:\n print('ERROR in load_tweets.')\n\n return data",
"def test_loader_loads_from_file():\n base_json = 'tests/test_json.json'\n json_test = {\"foo\": \"bar\"}\n as... | [
"0.64222986",
"0.61474323",
"0.6144654",
"0.61129427",
"0.6093864",
"0.6074711",
"0.6030403",
"0.59984696",
"0.59946185",
"0.59418505",
"0.59320986",
"0.58631575",
"0.5842694",
"0.5824927",
"0.57905143",
"0.5786703",
"0.5777964",
"0.57755256",
"0.5758631",
"0.57461494",
"0.57... | 0.7133785 | 0 |
Load data from either a .json file, an open file pointer or a json string. Directly returns any other data. | def _load_json(self, kind, source, **kwargs):
if source is None:
raise exceptions.invalid_json_map[kind](f"Cannot load {kind} - no data source specified.")
# Decode the json string and deserialize to objects.
try:
data = load_json(source, **kwargs)
except FileNotFoundError as e:
raise exceptions.file_not_found_map[kind](e)
except jsonlib.decoder.JSONDecodeError as e:
raise exceptions.invalid_json_map[kind](e)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_data_from_file(self, input_file_path):\n with FileOrBufferHandler(input_file_path, 'r', \n encoding=self.file_encoding) as input_file:\n try:\n data = json.load(input_file)\n except (json.JSONDecodeError, UnicodeDecodeError):\n ... | [
"0.74808633",
"0.7463258",
"0.7429995",
"0.7426092",
"0.73366517",
"0.72446245",
"0.7234326",
"0.7181051",
"0.7129091",
"0.71012217",
"0.7058075",
"0.70502263",
"0.7007759",
"0.6973326",
"0.69674516",
"0.6960993",
"0.69258857",
"0.69136333",
"0.6907644",
"0.6902104",
"0.68784... | 0.7064134 | 10 |
Get the schema for the given strand. | def _get_schema(self, strand):
if strand == "twine":
# The data is a twine. A twine *contains* schema, but we also need to verify that it matches a certain
# schema itself. The twine schema is distributed with this packaged to ensure version consistency...
schema_path = "schema/twine_schema.json"
elif strand in CHILDREN_STRANDS:
# The data is a list of children. The "children" strand of the twine describes matching criteria for
# the children, not the schema of the "children" data, which is distributed with this package to ensure
# version consistency...
schema_path = "schema/children_schema.json"
elif strand in MANIFEST_STRANDS:
# The data is a manifest of files. The "*_manifest" strands of the twine describe matching criteria used to
# filter files appropriate for consumption by the digital twin, not the schema of the manifest data, which
# is distributed with this package to ensure version consistency...
schema_path = "schema/manifest_schema.json"
else:
if strand not in SCHEMA_STRANDS:
raise exceptions.UnknownStrand(f"Unknown strand {strand}. Try one of {ALL_STRANDS}.")
# Get schema from twine.json file.
schema_key = strand + "_schema"
try:
return getattr(self, schema_key)
except AttributeError:
raise exceptions.StrandNotFound(f"Cannot validate - no {schema_key} strand in the twine")
return jsonlib.loads(pkg_resources.resource_string("twined", schema_path)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_schema(self):\n self._pick()\n return Schema()",
"def _get_schema_using_query(self, query: str) -> sch.Schema:\n return sch.Schema.from_tuples(self._metadata(query))",
"def schema(self):\n return _parse_schema_resource(self._properties.get(\"schema\", {}))",
"def get_sche... | [
"0.66698045",
"0.6518725",
"0.6390867",
"0.6313399",
"0.6210594",
"0.62096435",
"0.61262435",
"0.61096203",
"0.6025287",
"0.5981262",
"0.5939648",
"0.5933518",
"0.5902661",
"0.58778864",
"0.5872866",
"0.58726424",
"0.58520615",
"0.58372164",
"0.58244634",
"0.5824207",
"0.5819... | 0.8233626 | 0 |
Validate data against a schema, raises exceptions of type InvalidJson if not compliant. | def _validate_against_schema(self, strand, data):
schema = self._get_schema(strand)
try:
jsonschema_validate(instance=data, schema=schema)
logger.debug("Validated %s against schema", strand)
except ValidationError as e:
raise exceptions.invalid_contents_map[strand](str(e)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate(self, json_data):\n self._errors = None\n success = True\n for item in self._schema:\n if not item.validate(json_data):\n success = False\n\n return success",
"def validate_schema(*,\n jsonschema: dict,\n dat... | [
"0.7925582",
"0.78330433",
"0.7702376",
"0.7666036",
"0.7600036",
"0.75039744",
"0.75000393",
"0.74321485",
"0.73822933",
"0.73632777",
"0.7302417",
"0.72996646",
"0.7248956",
"0.71885204",
"0.718743",
"0.7182984",
"0.69556284",
"0.6946508",
"0.69202065",
"0.6914744",
"0.6913... | 0.76444364 | 4 |
Validate that the installed version is consistent with an optional version specification in the twine file. | def _validate_twine_version(self, twine_file_twined_version):
installed_twined_version = pkg_resources.get_distribution("twined").version
logger.debug(
"Twine versions... %s installed, %s specified in twine", installed_twined_version, twine_file_twined_version
)
if (twine_file_twined_version is not None) and (installed_twined_version != twine_file_twined_version):
raise exceptions.TwineVersionConflict(
f"Twined library version conflict. Twine file requires {twine_file_twined_version} but you have {installed_twined_version} installed"
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_valid_version(self):\n pass",
"def validate_configurator_version():\n if settings.CONFIGURATOR_MODULE == \"bootmachine.contrib.configurators.salt\":\n pkgver = settings.SALT_AUR_PKGVER\n pkgrel = settings.SALT_AUR_PKGREL\n response = urllib2.urlopen(\"https://aur.archlinux.o... | [
"0.6902856",
"0.6780541",
"0.67345285",
"0.6424998",
"0.6407822",
"0.64057225",
"0.6383413",
"0.6376578",
"0.6337082",
"0.6273863",
"0.6264896",
"0.62600714",
"0.6233149",
"0.62270665",
"0.6219592",
"0.61668104",
"0.61236084",
"0.6105264",
"0.60952014",
"0.60824794",
"0.60168... | 0.7964266 | 0 |
Validate values against the twine schema. | def _validate_values(self, kind, source, cls=None, **kwargs):
data = self._load_json(kind, source, **kwargs)
self._validate_against_schema(kind, data)
if cls:
return cls(**data)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate():",
"def validate(self, name, values):\r\n \r\n pass",
"def is_schema_valid(self, schema):\n for k, v in schema.items():\n if v[0] == \"var_len\":\n assert len(v) == 2\n assert v[1] in TF_VALUE\n\n if v[0] == \"fixed_len\":\... | [
"0.6888409",
"0.6783357",
"0.6623987",
"0.6546313",
"0.6526652",
"0.6525666",
"0.64644414",
"0.6449077",
"0.6449077",
"0.64253944",
"0.6407268",
"0.63882005",
"0.6381051",
"0.63460135",
"0.63460135",
"0.6308076",
"0.6282616",
"0.6282616",
"0.6281018",
"0.62414503",
"0.6232009... | 0.0 | -1 |
Validate manifest against the twine schema. | def _validate_manifest(self, kind, source, cls=None, **kwargs):
data = self._load_json(kind, source, **kwargs)
# TODO elegant way of cleaning up this nasty serialisation hack to manage conversion of outbound manifests to primitive
inbound = True
if hasattr(data, "to_primitive"):
inbound = False
data = data.to_primitive()
self._validate_against_schema(kind, data)
self._validate_all_expected_datasets_are_present_in_manifest(manifest_kind=kind, manifest=data)
if cls and inbound:
return cls(**data)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_manifest(\n request: ValidateManifestRequest = Body(...),\n schema: Any = Depends(get_description_schema),\n) -> ValidateManifestResponse:\n\n _, response = _validate_manifest(request, schema)\n return response",
"def validate_input_manifest(self, source, **kwargs):\n return self.... | [
"0.70706165",
"0.67949265",
"0.6726037",
"0.6626515",
"0.6575376",
"0.650649",
"0.6169406",
"0.6119033",
"0.6040567",
"0.59697014",
"0.59644884",
"0.59519655",
"0.5935721",
"0.591002",
"0.5886837",
"0.58650386",
"0.5852848",
"0.5783439",
"0.5762712",
"0.5759838",
"0.5739801",... | 0.6218101 | 6 |
Check that all nonoptional datasets specified in the corresponding manifest strand in the twine are present in the given manifest. | def _validate_all_expected_datasets_are_present_in_manifest(self, manifest_kind, manifest):
# This is the manifest schema included in the `twine.json` file, not the schema for `manifest.json` files.
manifest_schema = getattr(self, manifest_kind)
for expected_dataset_name, expected_dataset_schema in manifest_schema["datasets"].items():
if expected_dataset_name in manifest["datasets"]:
continue
if expected_dataset_schema.get("optional", False):
continue
raise exceptions.invalid_contents_map[manifest_kind](
f"A dataset named {expected_dataset_name!r} is expected in the {manifest_kind} but is missing."
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_manifest(manifest):\n if not manifest:\n raise Exception('manifest is null')\n\n for key in ['dublin_core', 'checking', 'projects']:\n if key not in manifest:\n raise Exception('manifest missing key \"{0}\"'.format(key))\n\n # check checking\n ... | [
"0.68781096",
"0.5914848",
"0.5894921",
"0.58664596",
"0.5797446",
"0.5790559",
"0.575301",
"0.57257426",
"0.56155634",
"0.5589998",
"0.55779296",
"0.5571627",
"0.55710405",
"0.5568376",
"0.55295604",
"0.5499033",
"0.5491544",
"0.5466877",
"0.54596764",
"0.5446938",
"0.542575... | 0.7935964 | 0 |
Get the names of strands that are found in this twine. | def available_strands(self):
return self._available_strands | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iter_strands(self):\n return iter(self.strand_list)",
"def getStationsName(self) :\n names = []\n for sts in self._stations :\n names.append(sts.getName())\n\n return names",
"def get_well_aliases(self):\n return self.info_wells['well'].unique()",
"def list_a... | [
"0.6584263",
"0.65621185",
"0.63851863",
"0.62019277",
"0.61951375",
"0.60891676",
"0.60425985",
"0.6007916",
"0.59496164",
"0.59036535",
"0.5884974",
"0.58607626",
"0.57966846",
"0.57783294",
"0.5773814",
"0.5770074",
"0.57655287",
"0.5721144",
"0.5684944",
"0.5684944",
"0.5... | 0.71010107 | 0 |
Get the names of the manifest strands that are found in this twine. | def available_manifest_strands(self):
return self._available_manifest_strands | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def available_strands(self):\n return self._available_strands",
"def list_manifests():\n import enaml\n with enaml.imports():\n from .pulses.manifest import PulsesManagerManifest\n from .tasks.manifest import PulsesTasksManifest\n from .measure.manifest import PulsesMeasureManif... | [
"0.6490598",
"0.61462444",
"0.6061251",
"0.6059069",
"0.59545153",
"0.59168273",
"0.5911148",
"0.5903504",
"0.5897712",
"0.5851716",
"0.58406675",
"0.5829558",
"0.58154243",
"0.5781835",
"0.57704556",
"0.57661283",
"0.57341903",
"0.56977165",
"0.56977165",
"0.56939626",
"0.56... | 0.7861807 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.