KM.Model:\\n\\n # For decoder number of features in opposite order of encoder\\n decoder_features = self.encoder_features.copy()\\n decoder_features.reverse()\\n\\n # build the encoder model\\n self.encoder_model = self.encoder(\\n features=self.encoder_features, name=\\\"encoder\\\"\\n )\\n\\n # build the decoder model\\n decoder = self.decoder(features=decoder_features, name=\\\"decoder\\\")\\n\\n input_tensor = KL.Input(\\n shape=(32, 32, 3)\\n ) # shape of images for cifar10 dataset\\n\\n # Encode the images\\n encoded = self.encoder_model(input_tensor)\\n # Decode the image\\n decoded = decoder(encoded[-1])\\n\\n return KM.Model(inputs=input_tensor, outputs=decoded, name=\\\"AutoEncoder\\\")\",\n \"def build(self):\\n pass\",\n \"def build(self):\\n pass\",\n \"def __init__(self, *args):\\n this = _libsbml.new_ModelCreator(*args)\\n try: self.this.append(this)\\n except: self.this = this\",\n \"def build(self):\\n\\n raise NotImplementedError(\\\"Implement build() method\\\")\",\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 create_model(self):\\n self.create_model_file()\\n self.create_model_unit_test()\\n self.add_model_to_list()\\n self.readme_reminder()\",\n \"def createModel(self):\\n outputs, inputs = baseUNet(self.input_shape,\\n self.conv_depth,\\n self.n_classes,\\n self.init_w,\\n self.dropout)\\n \\n if self.regression == True:\\n outputs = Lambda(getPropOfGround)(outputs)\\n \\n model = Model(inputs = inputs,outputs = outputs)\\n \\n model.compile(optimizer = self.optimizer,\\n loss=self.loss_function,\\n metrics=self.metrics)\\n\\n if self.old_weights != None:\\n model.set_weights(self.old_weights)\\n self.model = model\",\n \"def _build_models(self):\\n with tf.variable_scope('model'):\\n meval = Model(self.hparams, mode='test')\\n meval.build()\\n self._saver = meval.saver\\n\\n self.meval = meval\",\n \"def build_model(training_info, model, db_url=None):\\n r2dt.build_model(training_info, db_url, Path(model))\",\n \"def build_model_from_inputs(self):\\n if self.term_list is None:\\n # no supplied token list -- use vocabulary of the training dataset\\n # self.term_list = self.vocabulary\\n # info(\\\"Setting bag dimension to {} from input vocabulary.\\\".format(len(self.term_list)))\\n # will generate the vocabulary from the input\\n pass\\n info(f\\\"Building {self.name} model\\\")\\n bagger = None\\n if self.config.max_terms is not None:\\n bagger = Bag(vocabulary=self.term_list, weighting=self.base_name, ngram_range=self.ngram_range, max_terms=self.config.max_terms)\\n else:\\n bagger = Bag(vocabulary=self.term_list, weighting=self.base_name, ngram_range=self.ngram_range)\\n\\n train_idx = self.indices.get_train_instances()\\n texts = Text.get_strings(self.text.data.get_slice(train_idx))\\n bagger.map_collection(texts, fit=True, transform=False)\\n self.term_list = bagger.get_vocabulary()\\n\\n self.dimension = len(self.term_list)\\n self.config.dimension = self.dimension\",\n \"def make(model: Type[Model], **kwargs: Any) -> Model:\\n return modelfactory_factory(model)(**kwargs)\",\n \"def build_model(cls, args, task):\\n\\n # make sure all arguments are present in older models\\n base_lm_architecture(args)\\n\\n if args.decoder_layers_to_keep:\\n args.decoder_layers = len(args.decoder_layers_to_keep.split(\\\",\\\"))\\n\\n if getattr(args, \\\"max_target_positions\\\", None) is None:\\n args.max_target_positions = getattr(\\n args, \\\"tokens_per_sample\\\", DEFAULT_MAX_TARGET_POSITIONS\\n )\\n\\n if args.character_embeddings:\\n embed_tokens = CharacterTokenEmbedder(\\n task.source_dictionary,\\n eval(args.character_filters),\\n args.character_embedding_dim,\\n args.decoder_embed_dim,\\n args.char_embedder_highway_layers,\\n )\\n elif args.adaptive_input:\\n embed_tokens = AdaptiveInput(\\n len(task.source_dictionary),\\n task.source_dictionary.pad(),\\n args.decoder_input_dim,\\n args.adaptive_input_factor,\\n args.decoder_embed_dim,\\n options.eval_str_list(args.adaptive_input_cutoff, type=int),\\n args.quant_noise_pq,\\n args.quant_noise_pq_block_size,\\n )\\n else:\\n embed_tokens = cls.build_embedding(\\n args, task.source_dictionary, args.decoder_input_dim\\n )\\n\\n if args.tie_adaptive_weights:\\n assert args.adaptive_input\\n assert args.adaptive_input_factor == args.adaptive_softmax_factor\\n assert (\\n args.adaptive_softmax_cutoff == args.adaptive_input_cutoff\\n ), \\\"{} != {}\\\".format(\\n args.adaptive_softmax_cutoff, args.adaptive_input_cutoff\\n )\\n assert args.decoder_input_dim == args.decoder_output_dim\\n\\n decoder = LinearTransformerDecoder(\\n args, task.target_dictionary, embed_tokens, no_encoder_attn=True\\n )\\n return cls(decoder)\",\n \"def create_model(self):\\n # Create the generator and discriminators\\n self.generator_lungs = self.generator_model()\\n self.generator_organs = self.generator_model()\\n\\n self.disc_lungs = self.discriminator_model_lungs()\\n self.disc_organs = self.discriminator_model_organs()\\n\\n # Initialize the optimizer and backend\\n self.generator_optimizer = tf.keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)\\n self.discriminator_optimizer = tf.keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)\\n self.set_backend = tf.keras.backend.set_floatx('float32')\\n\\n # Create the summary writer\\n self.create_summary_writer()\\n print('Models are created.')\\n return self\",\n \"def _load_from(cls, model_state: dict) -> AbstractModel:\\n return cls(model=model_state.get('model'), **model_state.get('kwargs'))\",\n \"def create_model(self) -> None:\\n self._model = create_model_with_temperature_scaling(self.config)\",\n \"def build_retrieval_model(cfg):\\n logging.info(\\\"Building model....\\\")\\n model = build_model(cfg.MODEL, cfg.OPTIMIZER)\\n if g_pathmgr.exists(cfg.MODEL.WEIGHTS_INIT.PARAMS_FILE):\\n init_weights_path = cfg.MODEL.WEIGHTS_INIT.PARAMS_FILE\\n logging.info(f\\\"Initializing model from: {init_weights_path}\\\")\\n weights = load_checkpoint(init_weights_path, device=torch.device(\\\"cuda\\\"))\\n skip_layers = cfg.MODEL.WEIGHTS_INIT.get(\\\"SKIP_LAYERS\\\", [])\\n replace_prefix = cfg.MODEL.WEIGHTS_INIT.get(\\\"REMOVE_PREFIX\\\", None)\\n append_prefix = cfg.MODEL.WEIGHTS_INIT.get(\\\"APPEND_PREFIX\\\", None)\\n state_dict_key_name = cfg.MODEL.WEIGHTS_INIT.get(\\\"STATE_DICT_KEY_NAME\\\", None)\\n\\n init_model_from_consolidated_weights(\\n cfg,\\n model,\\n weights,\\n state_dict_key_name=state_dict_key_name,\\n skip_layers=skip_layers,\\n replace_prefix=replace_prefix,\\n append_prefix=append_prefix,\\n )\\n else:\\n # We only throw the warning if not weights file is provided. We want to\\n # benchmark the random initialization model too and hence support that.\\n logging.warning(\\\"Model is randomly initialized....\\\")\\n logging.info(f\\\"Model is:\\\\n {model}\\\")\\n return model\",\n \"def build_model(self):\\n # Define input layer (states)\\n states = K.layers.Input(shape=(self.state_size,), name='states')\\n net = states\\n # Add the hidden layers\\n for layer_count in range(len(self.layer_sizes)):\\n net = K.layers.Dense(units=self.layer_sizes[layer_count])(net)\\n net = K.layers.Activation('relu')(net)\\n if self.batch_norm_options[layer_count]:\\n net = K.layers.BatchNormalization()(net)\\n net = K.layers.Dropout(self.dropout_options[layer_count])(net)\\n\\n # Add final output layer with sigmoid activation\\n actions = K.layers.Dense(units=self.action_size, activation='linear',\\n name='raw_actions')(net)\\n\\n # Create Keras model\\n self.model = K.models.Model(inputs=states, outputs=actions)\\n\\n # Print the created model summary\\n self.logger.debug(\\\"Model Summery:\\\")\\n self.model.summary(print_fn=self.logger.debug)\\n\\n # Define optimizer and training function\\n self.optimizer = K.optimizers.Adam(lr=self.learning_rate)\\n self.model.compile(loss='mse', optimizer=self.optimizer)\",\n \"def build():\",\n \"def __init__(self, *args):\\n this = _libsbml.new_Model(*args)\\n try: self.this.append(this)\\n except: self.this = this\",\n \"def build_model_input(cls, name='input'):\\n return cls(name, PortDirection.INPUT, type=PortType.MODEL)\",\n \"def build(self, *args, **kwargs):\\n return\",\n \"def _build_models(self):\\n # Determine if we should build the train and eval model. When using\\n # distributed training we only want to build one or the other and not both.\\n with tf.variable_scope('model', use_resource=False):\\n m = CifarModel(self.hparams)\\n m.build('train')\\n self._num_trainable_params = m.num_trainable_params\\n self._saver = m.saver\\n with tf.variable_scope('model', reuse=True, use_resource=False):\\n meval = CifarModel(self.hparams)\\n meval.build('eval')\\n return m, meval\",\n \"def build_model(self, model_def_path: Optional[str] = None) -> 'nn.Module':\\n cfg = self.cfg\\n model = cfg.model.build(\\n num_classes=cfg.data.num_classes,\\n in_channels=cfg.data.img_channels,\\n save_dir=self.modules_dir,\\n hubconf_dir=model_def_path,\\n img_sz=cfg.data.img_sz)\\n return model\",\n \"def build_model(self):\\n input_pencil = tf.keras.Input((128,128,3))\\n # generator's output\\n gen_image = self.gan_generator.model(input_pencil)\\n # generator's output\\n x = self.gan_discriminator.model([input_pencil,gen_image])\\n model = tf.keras.Model(input_pencil,[x,gen_image])\\n # compiling the model\\n model.compile(loss=['hinge', 'mae'], optimizer = self.optimizer,loss_weights=[1,100], metrics=['accuracy'])\\n self.model = 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 __pull_model(self):\\n\\n model = ArmModeler().get(self.name)\\n\\n if model:\\n logger.debug(\\\"model creating...\\\")\\n self.alpha = model[\\\"alpha\\\"]\\n self.a = model[\\\"a\\\"]\\n self.q = model[\\\"q\\\"]\\n self.d = model[\\\"d\\\"]\\n self.dh_params = model[\\\"dh_params\\\"]\\n self.tf_matrices_list = model[\\\"transform_matrices\\\"]\\n self.jacobian_matrix = model[\\\"jacobian_matrix\\\"]\\n\\n else:\\n ArmModeler().create(self.name)\\n self.__pull_model()\",\n \"def _build(self):\\n raise NotImplementedError()\",\n \"def build_model(self, input_shape, design_embedding, **kwargs):\\n return design_embedding(input_shape)\",\n \"def build_model(spec, log_path):\\n\\n # Part of the model to train\\n if spec.train_region_layer is not None:\\n train_layer = int(spec.train_region_layer[1])\\n train_region = spec.train_region_layer[0]\\n else:\\n train_layer = train_region = None\\n\\n # Model hyper-parameters\\n encoding_spec = [dict(\\n n_hidden=units, batch_size=spec.batch_size,\\n l2_const=spec.l2_const, sparsity_const=spec.sparsity_const,\\n sparsity_target=spec.sparsity_target,\\n ) for units in spec.network_size\\n ]\\n genetic_spec = dict(\\n n_individuals=spec.population_size,\\n mutation_p=spec.mutation_p,\\n crossover_p=spec.crossover_p,\\n fitness_range=spec.fitness_range,\\n n_episodes=spec.fitness_episodes,\\n )\\n\\n # Model\\n model = models.Fluents(\\n env_name=spec.env,\\n dbn_spec=encoding_spec,\\n ga_spec=genetic_spec,\\n training_layer=train_layer,\\n training_region=train_region,\\n receiver_gen=lambda: atari_frames_generator(spec.env, spec.stream),\\n logdir=log_path,\\n )\\n\\n return model\",\n \"def create_model():\\n\\n class Net(nn.Cell):\\n def construct(self, x, y):\\n return x\\n\\n net = Net()\\n model_simple = Model(net)\\n\\n return model_simple\",\n \"def build(self, **other_kwargs):\\n raise NotImplementedError()\",\n \"def create_model(self):\\n self.model = None\\n pass\",\n \"def build(obs_space: Box, action_space: Box, spec: Spec) -> MLPModel:\\n model = MLPModel(obs_space, action_space, spec.network)\\n model.initialize_parameters(spec.initializer)\\n if spec.residual:\\n model = ResidualStochasticModel(model)\\n return model\",\n \"def build_model(cls, args):\\n base_architecture(args) \\n return StyleGANGeneratorPretrain(args)\",\n \"def _build(self, model):\\t# pylint: disable=unused-argument,no-self-use\\n\\t\\treturn iter(())\",\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 _create_model(self):\\n config = {\\n \\\"input_features\\\": self.input_features,\\n \\\"output_features\\\": self.output_features,\\n \\\"combiner\\\": {\\\"type\\\": \\\"concat\\\", \\\"output_size\\\": 14},\\n TRAINER: {\\\"epochs\\\": 2, BATCH_SIZE: 128},\\n }\\n return LudwigModel(config, logging_level=logging.WARN)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8193063","0.81708336","0.81708336","0.8142892","0.80082697","0.8007576","0.7792786","0.7418838","0.73600554","0.73502004","0.71278006","0.71252024","0.7077948","0.7076256","0.7055581","0.7055581","0.69957775","0.69957775","0.69845784","0.6895667","0.6873882","0.6873811","0.683921","0.6831486","0.6805285","0.6771797","0.6744565","0.6709163","0.6707222","0.6706357","0.66650814","0.6660991","0.66230303","0.65608823","0.6543151","0.65408814","0.65408814","0.652019","0.6519213","0.65165657","0.65138006","0.65115577","0.65114325","0.65082866","0.64757377","0.6474868","0.64726883","0.6465799","0.6460183","0.64568263","0.64520335","0.64168173","0.6406512","0.6405538","0.6404326","0.6364881","0.63641864","0.63591015","0.6344277","0.63270664","0.6322464","0.63159406","0.63140035","0.6306382","0.6306382","0.6300666","0.62929165","0.62910765","0.62889755","0.6286956","0.62826765","0.6274809","0.6268938","0.6255408","0.6250566","0.62476623","0.6238663","0.6236124","0.6231918","0.62128276","0.6187613","0.6184584","0.61797994","0.6177804","0.6168492","0.6166995","0.6162184","0.6158148","0.6137153","0.6136777","0.61255836","0.6124257","0.6120579","0.61035126","0.60986745","0.6065436","0.60635495","0.606237","0.6061242","0.6060555"],"string":"[\n \"0.8193063\",\n \"0.81708336\",\n \"0.81708336\",\n \"0.8142892\",\n \"0.80082697\",\n \"0.8007576\",\n \"0.7792786\",\n \"0.7418838\",\n \"0.73600554\",\n \"0.73502004\",\n \"0.71278006\",\n \"0.71252024\",\n \"0.7077948\",\n \"0.7076256\",\n \"0.7055581\",\n \"0.7055581\",\n \"0.69957775\",\n \"0.69957775\",\n \"0.69845784\",\n \"0.6895667\",\n \"0.6873882\",\n \"0.6873811\",\n \"0.683921\",\n \"0.6831486\",\n \"0.6805285\",\n \"0.6771797\",\n \"0.6744565\",\n \"0.6709163\",\n \"0.6707222\",\n \"0.6706357\",\n \"0.66650814\",\n \"0.6660991\",\n \"0.66230303\",\n \"0.65608823\",\n \"0.6543151\",\n \"0.65408814\",\n \"0.65408814\",\n \"0.652019\",\n \"0.6519213\",\n \"0.65165657\",\n \"0.65138006\",\n \"0.65115577\",\n \"0.65114325\",\n \"0.65082866\",\n \"0.64757377\",\n \"0.6474868\",\n \"0.64726883\",\n \"0.6465799\",\n \"0.6460183\",\n \"0.64568263\",\n \"0.64520335\",\n \"0.64168173\",\n \"0.6406512\",\n \"0.6405538\",\n \"0.6404326\",\n \"0.6364881\",\n \"0.63641864\",\n \"0.63591015\",\n \"0.6344277\",\n \"0.63270664\",\n \"0.6322464\",\n \"0.63159406\",\n \"0.63140035\",\n \"0.6306382\",\n \"0.6306382\",\n \"0.6300666\",\n \"0.62929165\",\n \"0.62910765\",\n \"0.62889755\",\n \"0.6286956\",\n \"0.62826765\",\n \"0.6274809\",\n \"0.6268938\",\n \"0.6255408\",\n \"0.6250566\",\n \"0.62476623\",\n \"0.6238663\",\n \"0.6236124\",\n \"0.6231918\",\n \"0.62128276\",\n \"0.6187613\",\n \"0.6184584\",\n \"0.61797994\",\n \"0.6177804\",\n \"0.6168492\",\n \"0.6166995\",\n \"0.6162184\",\n \"0.6158148\",\n \"0.6137153\",\n \"0.6136777\",\n \"0.61255836\",\n \"0.6124257\",\n \"0.6120579\",\n \"0.61035126\",\n \"0.60986745\",\n \"0.6065436\",\n \"0.60635495\",\n \"0.606237\",\n \"0.6061242\",\n \"0.6060555\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7413572"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":23997,"cells":{"query":{"kind":"string","value":"Get targets from either the sample or the net's output."},"document":{"kind":"string","value":"def get_targets(self, sample, net_output):\n return sample[\"target\"]"},"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_targets(self):\n\t\treturn self.prDoc['inputs']['data'][0]['targets']","def output_targets(self, input_targets):\n return input_targets","def output_targets(self) -> Set[str]:\n return {\n out.target\n for out in\n self.outputs\n }","def output_targets(self, input_targets):\n pass","def get_targets(self):\n\t\n\t\tself.target = []\n\t\ttarget_ins = self.settings['target']\n\t\tfor key in target_ins.keys():\n\t\t\tif key == 'raw':\n\t\t\t\tself.target.append(target_ins[key])\n\t\t\telif key == 'textfile':\n\t\t\t\twith open(target_ins[key],'r') as fp: targs = fp.readlines()\n\t\t\t\tfor t in targs:\n\t\t\t\t\tif re.match('^[a-z,A-Z,_].+\\s*:\\s*[A-Z].+$',t):\n\t\t\t\t\t\tself.target.append(tuple([i.strip() for i in t.split(':')]))\n\t\t\telif key == 'textfile_rna':\n\t\t\t\twith open(target_ins[key],'r') as fp: targs = fp.readlines()\n\t\t\t\tfor t in targs:\n\t\t\t\t\tif re.match('^[a-z,A-Z,0-9,_].+\\s*:\\s*[A-Z,a-z].+$',t):\n\t\t\t\t\t\tself.target.append(list([i.strip() for i in t.split(':')]))\n\t\t\t\t\t\trnaseq = self.target[-1][1]\n\t\t\t\t\t\t#---extra substitutions for later\n\t\t\t\t\t\tif 'regex_subs' in self.settings.keys():\n\t\t\t\t\t\t\tfor regex in self.settings['regex_subs']:\n\t\t\t\t\t\t\t\trnaseq = re.sub(regex[0],regex[1],rnaseq)\n\t\t\t\t\t\trnaseq = rnaseq.upper()\n\t\t\t\t\t\trnaseq = re.sub('T','U',rnaseq)\n\t\t\t\t\t\taminoseq = ''.join([dna_mapping[i] for i in [rnaseq[i:i+3] \n\t\t\t\t\t\t\tfor i in range(0,len(rnaseq),3)]])\n\t\t\t\t\t\tself.target[-1][1] = re.sub('T','U',aminoseq)\n\t\t\t\t\t\tself.target[-1] = tuple(self.target[-1])\n\t\t\telse: raise Exception('except: unclear target type')","def _get_targets(input_: Optional[Collection],\n all_: Collection[Any],\n type_: str,\n ) -> Collection[Any]:\n if input_ is None:\n return all_\n target = []\n for item in input_:\n if item not in all_:\n logger.warning(f'unknown target {type_}: {item}')\n continue\n target.append(item)\n return target","def collectTargets(self, output):\n pass","def get_targets(self, data_samples: List[TextDetDataSample]) -> Tuple:\n\n # If data_samples points to same object as self.cached_data_samples, it\n # means that get_targets is called more than once in the same train\n # iteration, and pre-computed targets can be reused.\n if hasattr(self, 'targets') and \\\n self.cache_data_samples is data_samples:\n return self.targets\n\n self.cache_data_samples = data_samples\n self.targets = multi_apply(self._get_target_single, data_samples)\n return self.targets","def GetTargets(self):\n return []","def ProduceTargets(self):\n\n if self.completion_wanted:\n return self._FindTarget()\n else:\n return []","def Targets(self):\n return self._targets","def getBatchOutputs(self, src, net):\n pass","def targets(self) -> List[List[float]]:\n return [d.targets for d in self.data]","def get_targets(self, sort_by_dependency = False):\n\t\treturn self.__targets.get_targets(sort_by_dependency)","def get_targets() -> Generator[dict, dict, list[TargetInfo]]:\n response = yield {\"method\": \"Target.getTargets\", \"params\": {}}\n return [TargetInfo.from_json(t) for t in response[\"targetInfos\"]]","def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContactTargetsArgs']]]]:\n return pulumi.get(self, \"targets\")","def targets(self) -> Optional[Union[np.ndarray, Dict[str, np.ndarray]]]:\n return self._targets","def _get_inputs_targets(self, batch):\n return batch['lr_img'], batch['hr_img']","def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PlanTargetsArgs']]]]:\n return pulumi.get(self, \"targets\")","def _get_batch_targets(self, batch):\n try:\n return np.array(self._target_encoder.transform(batch))\n except AttributeError:\n return np.array(self._target_encoder(batch))","def targets(self) -> Optional[jnp.ndarray]:\n pass","def get_targets():\n # Use a list comp because querying MODM with Guid.find(Q('referent', 'eq', None))\n # only catches the first case.\n return [each for each in Guid.find() if each.referent is None]","def load_targets(self, sample_id):\n\n objects = self.get_label(sample_id)\n labels, noObjectLabels = kitti_bev_utils.read_labels_for_bevbox(objects)\n # on image space: targets are formatted as (class, x, y, w, l, sin(yaw), cos(yaw))\n targets = kitti_bev_utils.build_yolo_target(labels)\n\n return targets","def targets(self) -> List[Point2]:\n return self._targets","def targets(self):\n if self._targets is None:\n if self.verbose:\n print('Building targets from coco dataset')\n cacher = self._cacher('targets')\n _targets = cacher.tryload(on_error='clear')\n if _targets is None:\n _targets = tabular_coco_targets(self.dset)\n cacher.save(_targets)\n self._targets = _targets\n return self._targets","def targets(self):\n\n return [get_target_by_id(i) for i in self._target_ids]","def _get_targets(self, test_id):\n if isinstance(test_id, BGC) or isinstance(test_id, GCF): # genome side\n return self._get_targets_genomics(test_id)\n else: # metabolome side\n return self._get_targets_metabolomics(test_id)","def targets(self) -> Tensor:\n data_normalized = self._dataset_values.clone()\n data_normalized -= self._row_min\n data_normalized /= self._row_range\n _, outputs_normalized_transformed = self._transform(\n data_normalized[:, self._input_column_indices],\n data_normalized[:, self._output_column_indices],\n )\n assert outputs_normalized_transformed.ndim == 1 or (\n outputs_normalized_transformed.ndim == 2\n and outputs_normalized_transformed.size(1) == 1\n ), \".targets requires exactly one output column (to match TorchVision datasets).\"\n return outputs_normalized_transformed.view(-1).clone()","def console_output(self, targets):\r\n target_types = {}\r\n for target_type in SourceRoot._ROOTS_BY_TYPE.keys():\r\n target_types[target_type.__name__] = target_type\r\n\r\n if self.context.options.goal_targets_details is None:\r\n return self._get_installed_targets(target_types)\r\n else:\r\n return self._get_details(target_types[self.ALIAS_TO_TARGET[self.context.options.goal_targets_details]])","def get_all_targets():\n\n json_data = gtop.get_json_from_gtop(\"targets\")\n return [Target(t) for t in json_data]","def get_targets(\n self, source: Tuple[str, str], relation: Optional[str] = None\n ) -> List[Node]:\n return self.get_common_targets([source], relation)","def get_target_ports(self):\n return self.targets","def getResult(targets, i=None):","def targets(self, predicate=None):\r\n return filter(predicate, self._targets)","def build_targets(self, patterns):\n _targets = []\n for p in patterns:\n p = p.format_map(self.config)\n for s in self.samples:\n e = dict(s, **self.config)\n _targets.append(p.format_map(e))\n return list(set(_targets))","def get_targets(self, group_set, target_set=[]):\r\n result_id = []\r\n if not isinstance(group_set, list):\r\n for target in self._db(self._db.target).select():\r\n result_id.append(target.id)\r\n else:\r\n rows = self._db(self._db.targetgroup).select()\r\n for row in rows:\r\n if row.id in group_set:\r\n targets = json.loads(row.targets)\r\n for t_id in targets:\r\n result_id.append(self._db(self._db.target.id==t_id\r\n ).select().first().id)\r\n result_id += target_set\r\n\r\n result = []\r\n for target_id in set(result_id):\r\n result.append(self.get_target(target_id))\r\n\r\n return result","def getTargets():\n cams = CAMS\n for cam in cams:\n\n cam.resetTargets()\n cam.resetSizes()\n image = cam.getImage()\n print(\"Time before getting enemies: \" + str(time.time()))\n bloons, sizes = Vision_Processing.GetBalloon.getEnemies(image)\n print(\"Time after getting enemies: \" + str(time.time()))\n\n # print \"getTargets\"\n # print bloons\n\n points = []\n for bloon in bloons:\n points.append(np.array([bloon[0], bloon[1]]))\n for i in range(len(bloons)):\n cam.addTarget(points[i])\n cam.addSize(sizes[i])\n\n targets = triangulate()\n print(\"Time after triangulation: \" + str(time.time()))\n print \"getTargets\"\n print targets\n # targets = cartesianToSpheric(targets, place, orientation)\n return targets","def sample(self, net, numSamples=None):\n\n if numSamples is None:\n numSamples = self.numSamples\n\n\n if net.is_generator:\n\n configs = self._get_samples_gen(net, numSamples)\n\n return configs, net(configs), None\n\n\n configs, logPsi = self._get_samples_mcmc(net, numSamples)\n\n return configs, logPsi, None","def targets(self):\n\n\t\tstatus, targets = self.execute(self.mission, 'target_list', self.kingdom)\n\n\t\t# Nothing specified : default is everyone but me.\n\t\tif targets == self:\n\t\t\ttargets = Kingdom.objects.exclude(id=self.kingdom_id)\n\t\t\n\t\t# Pre-fetch user, for direct access to kingdom name.\n\t\tif isinstance(targets, QuerySet):\n\t\t\ttargets = targets.select_related('user')\n\n\t\treturn targets","def gather(self, outputs, target_device=None, dim=0):\n if not self.configer.get('network', 'gathered'):\n if target_device is None:\n target_device = list(range(torch.cuda.device_count()))[0]\n\n return torch_gather(outputs, target_device, dim=dim)\n\n else:\n return outputs","def __call__(self, images, targets):\n return images, targets","def get_extraction_target(inputs, outputs, to_extract, **loss_params):\n names = [[x.name for x in op.values()] for op in tf.get_default_graph().get_operations()]\n names = [y for x in names for y in x]\n\n r = re.compile(r'__GPU\\d__/')\n _targets = defaultdict(list)\n\n for name in names:\n name_without_gpu_prefix = r.sub('', name)\n for save_name, actual_name in to_extract.items():\n if actual_name in name_without_gpu_prefix:\n tensor = tf.get_default_graph().get_tensor_by_name(name)\n _targets[save_name].append(tensor)\n\n targets = {k: tf.concat(v, axis=0) for k, v in _targets.items()}\n targets['loss'] = utils.get_loss(inputs, outputs, **loss_params)\n return targets","def get_for_target(self, target):\n return self.get_for_targets([target])","def get_input(data):\n images, targets = data\n images = images.cuda()\n targets = [ann.cuda() for ann in targets]\n return images, targets","def targets(self, spec):\n\n spec_parser = CmdLineSpecParser(self.build_root, self.address_mapper)\n addresses = list(spec_parser.parse_addresses(spec))\n for address in addresses:\n self.build_graph.inject_address_closure(address)\n targets = [self.build_graph.get_target(address) for address in addresses]\n return targets","def targets(self): # type: () -> t.List[HostConfig]\n return self.host_settings.targets","def get_targets(conf):\r\n return [oslo.messaging.Target(topic=topic,\r\n exchange=conf.glance_control_exchange)\r\n for topic in conf.notification_topics]","def get_outputs(step):\n params = step.get('parameters', {})\n outputs = params.get('outputs', [])\n for single_output in ['output', 'src_output', 'tgt_output']:\n if single_output in params:\n outputs.append(params[single_output])\n return outputs","def get_outputs(self):\n return self.outputs","def get_all_targets(self):\n return dict(self._targets)","def get_outputs(self):\n return [x[1] for x in self.io_mapping]","def make_targets(tgt_re, samples, target_suffix=\"\"):\n tgts = list(set(tgt_re.fmt.format(**unit) + target_suffix for unit in samples))\n return tgts","def GetRunTargets(self):\n return list(self._run_target_index.keys())","def get_outputs(self):\n raise NotImplementedError","def get_targets(self, rois: Tensor, rel_roi_points: Tensor,\n sampling_results: List[SamplingResult],\n batch_gt_instances: InstanceList,\n cfg: ConfigType) -> Tensor:\n\n num_imgs = len(sampling_results)\n rois_list = []\n rel_roi_points_list = []\n for batch_ind in range(num_imgs):\n inds = (rois[:, 0] == batch_ind)\n rois_list.append(rois[inds])\n rel_roi_points_list.append(rel_roi_points[inds])\n pos_assigned_gt_inds_list = [\n res.pos_assigned_gt_inds for res in sampling_results\n ]\n cfg_list = [cfg for _ in range(num_imgs)]\n\n point_targets = map(self._get_targets_single, rois_list,\n rel_roi_points_list, pos_assigned_gt_inds_list,\n batch_gt_instances, cfg_list)\n point_targets = list(point_targets)\n\n if len(point_targets) > 0:\n point_targets = torch.cat(point_targets)\n\n return point_targets","def _compute_targets_pytorch(self, ex_rois, gt_rois):\n\n assert ex_rois.size(1) == gt_rois.size(1)\n assert ex_rois.size(2) == 4\n assert gt_rois.size(2) == 4\n\n batch_size = ex_rois.size(0)\n rois_per_image = ex_rois.size(1)\n\n targets = bbox_transform_batch(ex_rois, gt_rois)\n\n if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:\n # Optionally normalize targets by a precomputed mean and stdev\n targets = ((targets - self.BBOX_NORMALIZE_MEANS.expand_as(targets))\n / self.BBOX_NORMALIZE_STDS.expand_as(targets))\n\n return targets","def _compute_targets_pytorch(self, ex_rois, gt_rois):\n\n assert ex_rois.size(1) == gt_rois.size(1)\n assert ex_rois.size(2) == 4\n assert gt_rois.size(2) == 4\n\n batch_size = ex_rois.size(0)\n rois_per_image = ex_rois.size(1)\n\n targets = bbox_transform_batch(ex_rois, gt_rois)\n\n if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:\n # Optionally normalize targets by a precomputed mean and stdev\n targets = ((targets - self.BBOX_NORMALIZE_MEANS.expand_as(targets))\n / self.BBOX_NORMALIZE_STDS.expand_as(targets))\n\n return targets","def get_targets(self, points: List[Tensor],\n batch_gt_instances_3d: InstanceList) -> Tuple[Tensor]:\n gt_labels_3d = [\n instances.labels_3d for instances in batch_gt_instances_3d\n ]\n gt_bboxes_3d = [\n instances.bboxes_3d for instances in batch_gt_instances_3d\n ]\n\n (bbox_targets, mask_targets, positive_mask, negative_mask,\n point_targets) = multi_apply(self.get_targets_single, points,\n gt_bboxes_3d, gt_labels_3d)\n\n bbox_targets = torch.stack(bbox_targets)\n mask_targets = torch.stack(mask_targets)\n positive_mask = torch.stack(positive_mask)\n negative_mask = torch.stack(negative_mask)\n box_loss_weights = positive_mask / (positive_mask.sum() + 1e-6)\n\n return (bbox_targets, mask_targets, positive_mask, negative_mask,\n box_loss_weights, point_targets)","def all_targets(self):\n return self._combined_all_versioned_targets.targets","def get_outputs(self):\n return self.attributes[\"outputs\"]","def targets(self):\n ret = {}\n for device in self.devices:\n ret[device.name] = device.name\n return ret","def targets(self) -> List[List[float]]:\n if self.preload:\n return [[j[QM9.U0].item()] for j in self.data_ram] # if data_ram is a array of dicts\n # return self.data_ram[QM9.U0].numpy() # if data_ram is a dict of arrays\n else:\n return [[j[QM9.U0].item()] for j in self.data]","def get_el_targets(params):\n data = queryDevice.queryDevice(\"\"\"\n SELECT DISTINCT dc.tid, dc.target_type, dc.dc, COUNT(DISTINCT act.assay_id), COUNT(DISTINCT activity_id)\n FROM assays ass\n JOIN(\n SELECT td.tid, td.target_type, COUNT(cd.domain_id) as dc\n FROM target_dictionary td\n JOIN target_components tc\n ON tc.tid = td.tid\n\t\t JOIN component_sequences cs\n\t\t\tON cs.component_id = tc.component_id\n JOIN component_domains cd\n \t\t\tON cd.component_id = cs.component_id\n WHERE td.target_type IN('SINGLE PROTEIN', 'PROTEIN COMPLEX')\n GROUP BY td.tid\n ) as dc\n ON dc.tid = ass.tid\n JOIN activities act\n ON act.assay_id = ass.assay_id\n WHERE act.standard_type IN('Ki','Kd','IC50','EC50', 'AC50')\n AND ass.relationship_type = 'D'\n AND assay_type IN('B')\n AND act.standard_relation IN('=')\n AND standard_units = 'nM'\n AND standard_value <= %s\n GROUP BY dc.tid ORDER BY COUNT(activity_id)\"\"\" % (int(params['threshold']) * 1000) , params)\n print \"retrieved data for \", len(data), \"tids.\"\n return data","def get_target(self):\n self.target = []\n for tags in self.cfg.target.split(\",\"):\n t = tags.split(\"=\")\n self.target.append({\"Key\": t[0], \"Values\": [t[1]]})\n\n return self.target","def get_targets(self,\n cls_scores_list,\n bbox_preds_list,\n gt_bboxes_list,\n gt_labels_list,\n gt_bboxes_ignore_list=None):\n assert gt_bboxes_ignore_list is None, \\\n 'Only supports for gt_bboxes_ignore setting to None.'\n num_imgs = len(cls_scores_list)\n gt_bboxes_ignore_list = [\n gt_bboxes_ignore_list for _ in range(num_imgs)\n ]\n\n (labels_list, label_weights_list, bbox_targets_list,\n bbox_weights_list, pos_inds_list, neg_inds_list) = multi_apply(\n self._get_target_single, cls_scores_list, bbox_preds_list,\n gt_labels_list, gt_bboxes_list, gt_bboxes_ignore_list)\n num_total_pos = sum((inds.numel() for inds in pos_inds_list))\n num_total_neg = sum((inds.numel() for inds in neg_inds_list))\n return (labels_list, label_weights_list, bbox_targets_list,\n bbox_weights_list, num_total_pos, num_total_neg)","def target(self, example):\n return example[self.target_index]","def get_targets(self, df):\n return df.iloc[:, self.target_col]","def only_targets(self, target_type): # type: (t.Type[THostConfig]) -> t.List[THostConfig]\n if not self.targets:\n raise Exception('There must be one or more targets.')\n\n assert type_guard(self.targets, target_type)\n\n return t.cast(t.List[THostConfig], self.targets)","def targets(obj, reftype):","def get_targets(units, basename, outdir, extensions = ['_fastqc.zip','_fastqc.html','.trim_fastqc.zip','.trim_fastqc.html'], se_ext = ['se'], pe_ext = ['1','2']):\n fastqc_targs = []\n for s, u in units.iterrows():\n sample, unit = u['sample'],u['unit']\n end = se_ext if is_se(units,sample,unit) else pe_ext\n fastqc_targs = fastqc_targs + ['{}_{}_'.format(sample,unit) + i + j for i in end for j in extensions]\n return [path.join(outdir, targ) for targ in fastqc_targs]","def compute_loc_targets(boxes, gt_boxes, weights=(1.0, 1.0, 1.0, 1.0)):\r\n ex_widths = boxes[:, 2] - boxes[:, 0] + 1.0\r\n ex_heights = boxes[:, 3] - boxes[:, 1] + 1.0\r\n ex_ctr_x = boxes[:, 0] + 0.5 * ex_widths\r\n ex_ctr_y = boxes[:, 1] + 0.5 * ex_heights\r\n\r\n gt_widths = gt_boxes[:, 2] - gt_boxes[:, 0] + 1.0\r\n gt_heights = gt_boxes[:, 3] - gt_boxes[:, 1] + 1.0\r\n gt_ctr_x = gt_boxes[:, 0] + 0.5 * gt_widths\r\n gt_ctr_y = gt_boxes[:, 1] + 0.5 * gt_heights\r\n\r\n wx, wy, ww, wh = weights\r\n targets_dx = wx * (gt_ctr_x - ex_ctr_x) / ex_widths\r\n targets_dy = wy * (gt_ctr_y - ex_ctr_y) / ex_heights\r\n targets_dw = ww * np.log(gt_widths / ex_widths)\r\n targets_dh = wh * np.log(gt_heights / ex_heights)\r\n\r\n targets = np.vstack((targets_dx, targets_dy, targets_dw,\r\n targets_dh)).transpose()\r\n return targets","def MakeSamplesFromOutput(metadata, output, use_tpu=False, model=RESNET):\n samples = []\n if RESNET in model:\n results = regex_util.ExtractAllMatches(\n f'Speed: ({RE_FLOAT}) samples/sec', output)\n results.extend(regex_util.ExtractAllMatches(\n f'\"imgs_sec\": ({RE_FLOAT})', output))\n results.extend(regex_util.ExtractAllMatches(\n f'\"key\": \"throughput\", \"value\": ({RE_FLOAT})', output))\n elif TRANSFORMER in model:\n results = re.findall(r'wps=(\\S+),', output)\n elif GNMT in model:\n results = re.findall(r'Tok/s (\\S+)', output)\n elif SSD in model:\n results = re.findall(r'avg. samples / sec: (\\S+)', output)\n elif MASK in model:\n results = regex_util.ExtractAllMatches(\n f'\"throughput\": ({RE_FLOAT})', output)\n results.extend(regex_util.ExtractAllMatches(\n f'\"key\": \"throughput\", \"value\": ({RE_FLOAT})', output))\n results.extend(regex_util.ExtractAllMatches(\n f'MLPERF METRIC THROUGHPUT=({RE_FLOAT}) iterations / s', output))\n elif BERT in model:\n results = regex_util.ExtractAllMatches(\n f\"'training_sequences_per_second': ({RE_FLOAT})\", output)\n for speed in results:\n samples.append(sample.Sample('speed', float(speed), 'samples/sec',\n metadata))\n\n if not use_tpu:\n if MINIGO in model:\n times = regex_util.ExtractAllMatches(r'RESULT,.*,(\\d+),.*,.*', output)\n else:\n times = regex_util.ExtractAllMatches(r'RESULT,.*,.*,(\\d+),.*,.*', output)\n samples.append(sample.Sample('Time', int(times[0]), 'seconds', metadata))\n\n samples.extend(MakeMLPerfSamplesFromOutput(metadata, output))\n return samples","def get_target(self):\n rospy.init_node('bot_control', anonymous=True)\n\n rospy.Subscriber('/predict_target', Float32MultiArray, self.callback)\n rospy.spin()","def __get_potential_targets(self):\n network_targets = {}\n for network in self.__get_scanning_range():\n ips = IPNetwork(network) # converts CIRD notation to IP addresses\n targets = []\n for ip in ips:\n targets.append(ip)\n print(\"Potential targets on {} network: {}\".format(network, len(targets)))\n network_targets.update({network: targets})\n return network_targets","def getMarkedTargets(markup):\n targets = markup.getConTextModeNodes(\"target\")\n targets.sort()\n return targets","def get_targets(self,\n anchor_list: List[List[Tensor]],\n valid_flag_list: List[List[Tensor]],\n batch_gt_instances: InstanceList,\n batch_img_metas: List[dict],\n batch_gt_instances_ignore: OptInstanceList = None,\n unmap_outputs: bool = True) -> tuple:\n num_imgs = len(batch_img_metas)\n assert len(anchor_list) == len(valid_flag_list) == num_imgs\n\n # anchor number of multi levels\n num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]\n num_level_anchors_list = [num_level_anchors] * num_imgs\n\n # concat all level anchors and flags to a single tensor\n for i in range(num_imgs):\n assert len(anchor_list[i]) == len(valid_flag_list[i])\n anchor_list[i] = torch.cat(anchor_list[i])\n valid_flag_list[i] = torch.cat(valid_flag_list[i])\n\n # compute targets for each image\n if batch_gt_instances_ignore is None:\n batch_gt_instances_ignore = [None] * num_imgs\n (all_anchors, all_labels, all_label_weights, all_bbox_targets,\n all_bbox_weights, pos_inds_list, neg_inds_list,\n sampling_results_list) = multi_apply(\n self._get_targets_single,\n anchor_list,\n valid_flag_list,\n num_level_anchors_list,\n batch_gt_instances,\n batch_img_metas,\n batch_gt_instances_ignore,\n unmap_outputs=unmap_outputs)\n # Get `avg_factor` of all images, which calculate in `SamplingResult`.\n # When using sampling method, avg_factor is usually the sum of\n # positive and negative priors. When using `PseudoSampler`,\n # `avg_factor` is usually equal to the number of positive priors.\n avg_factor = sum(\n [results.avg_factor for results in sampling_results_list])\n # split targets to a list w.r.t. multiple levels\n anchors_list = images_to_levels(all_anchors, num_level_anchors)\n labels_list = images_to_levels(all_labels, num_level_anchors)\n label_weights_list = images_to_levels(all_label_weights,\n num_level_anchors)\n bbox_targets_list = images_to_levels(all_bbox_targets,\n num_level_anchors)\n bbox_weights_list = images_to_levels(all_bbox_weights,\n num_level_anchors)\n return (anchors_list, labels_list, label_weights_list,\n bbox_targets_list, bbox_weights_list, avg_factor)","def _get_targets_single(self, rois: Tensor, rel_roi_points: Tensor,\n pos_assigned_gt_inds: Tensor,\n gt_instances: InstanceData,\n cfg: ConfigType) -> Tensor:\n num_pos = rois.size(0)\n num_points = cfg.num_points\n if num_pos > 0:\n gt_masks_th = (\n gt_instances.masks.to_tensor(rois.dtype,\n rois.device).index_select(\n 0, pos_assigned_gt_inds))\n gt_masks_th = gt_masks_th.unsqueeze(1)\n rel_img_points = rel_roi_point_to_rel_img_point(\n rois, rel_roi_points, gt_masks_th)\n point_targets = point_sample(gt_masks_th,\n rel_img_points).squeeze(1)\n else:\n point_targets = rois.new_zeros((0, num_points))\n return point_targets","def outputs(self):\n return self.outputs","def getTargets(targets) -> str:\n return\"\"\"## Target\n| |Category| |Task| Estimated Time | Actual Time |\n| - | -: | - | - | - | - |\n{previousTargets}\"\"\".format(previousTargets=targets)","def _get_targets_single(self, mask_preds: Tensor,\n gt_instances: InstanceData,\n positive_info: InstanceData):\n gt_bboxes = gt_instances.bboxes\n device = gt_bboxes.device\n gt_masks = gt_instances.masks.to_tensor(\n dtype=torch.bool, device=device).float()\n\n # process with mask targets\n pos_assigned_gt_inds = positive_info.get('pos_assigned_gt_inds')\n scores = positive_info.get('scores')\n centernesses = positive_info.get('centernesses')\n num_pos = pos_assigned_gt_inds.size(0)\n\n if gt_masks.size(0) == 0 or num_pos == 0:\n return mask_preds, None, 0\n # Since we're producing (near) full image masks,\n # it'd take too much vram to backprop on every single mask.\n # Thus we select only a subset.\n if (self.max_masks_to_train != -1) and \\\n (num_pos > self.max_masks_to_train):\n perm = torch.randperm(num_pos)\n select = perm[:self.max_masks_to_train]\n mask_preds = mask_preds[select]\n pos_assigned_gt_inds = pos_assigned_gt_inds[select]\n num_pos = self.max_masks_to_train\n elif self.topk_masks_per_img != -1:\n unique_gt_inds = pos_assigned_gt_inds.unique()\n num_inst_per_gt = max(\n int(self.topk_masks_per_img / len(unique_gt_inds)), 1)\n\n keep_mask_preds = []\n keep_pos_assigned_gt_inds = []\n for gt_ind in unique_gt_inds:\n per_inst_pos_inds = (pos_assigned_gt_inds == gt_ind)\n mask_preds_per_inst = mask_preds[per_inst_pos_inds]\n gt_inds_per_inst = pos_assigned_gt_inds[per_inst_pos_inds]\n if sum(per_inst_pos_inds) > num_inst_per_gt:\n per_inst_scores = scores[per_inst_pos_inds].sigmoid().max(\n dim=1)[0]\n per_inst_centerness = centernesses[\n per_inst_pos_inds].sigmoid().reshape(-1, )\n select = (per_inst_scores * per_inst_centerness).topk(\n k=num_inst_per_gt, dim=0)[1]\n mask_preds_per_inst = mask_preds_per_inst[select]\n gt_inds_per_inst = gt_inds_per_inst[select]\n keep_mask_preds.append(mask_preds_per_inst)\n keep_pos_assigned_gt_inds.append(gt_inds_per_inst)\n mask_preds = torch.cat(keep_mask_preds)\n pos_assigned_gt_inds = torch.cat(keep_pos_assigned_gt_inds)\n num_pos = pos_assigned_gt_inds.size(0)\n\n # Follow the origin implement\n start = int(self.mask_out_stride // 2)\n gt_masks = gt_masks[:, start::self.mask_out_stride,\n start::self.mask_out_stride]\n gt_masks = gt_masks.gt(0.5).float()\n pos_mask_targets = gt_masks[pos_assigned_gt_inds]\n\n return (mask_preds, pos_mask_targets, num_pos)","def outputs(self):\r\n return self._outputs","def get_ddqn_targets(qsa_target, q_targets, mask, estimator, next_states):\n with torch.no_grad():\n next_q_values = estimator(next_states)\n argmax_actions = next_q_values.max(1, keepdim=True)[1]\n qsa_target[mask] = q_targets.gather(1, argmax_actions)\n return qsa_target","def find_targetnodes(self):\n\n self.connect_backwards()\n\n targetnodes = []\n for n in self.find_datanodes():\n if len(n.receives_from) > 0:\n targetnodes.append(n)\n return targetnodes","def get_targets_for_group_key(self, key):\r\n\r\n return self.key_to_targets[key]","def get_next_target_addresses(self) -> List[str]:\n targets = []\n for edge in self._get_out_edges(self.active_pod):\n targets.append(self._get_target_pod(edge.pod).full_address)\n return targets","def read_targets(self):\n\n c = self.c\n\n new = []\n name = None\n\n for line in c.p.b.split('\\n'):\n\n if line.startswith('NAME: '):\n if name is not None:\n g.es(\"Error reading targets, two NAMEs without an UNL between them\")\n return\n name = line[6:].strip()\n continue\n\n if line.startswith('UNL: '):\n if name is None:\n g.es(\"Error reading targets, UNL without preceeding NAME\")\n return\n unl = line[5:].strip()\n new.append((name, unl))\n name = None\n continue\n\n # other lines are just ignored\n\n g.app.db['_quickmove']['global_targets'] = [\n {'name': name2, 'unl': unl2} for name2, unl2 in new\n ]\n # make sure g.app.db knows it's been changed\n g.app.db['_quickmove'] = g.app.db['_quickmove']\n\n g.es(\"%d targets read - you should delete this node now\" % len(new))","def target_ids(self):\n\n return self._target_ids","def get_target_tags(self):\n raise NotImplementedError(\"\")","def output_to_target(output, width, height):\n if isinstance(output, torch.Tensor):\n output = output.cpu().numpy()\n\n targets = []\n for i, o in enumerate(output):\n if o is not None:\n for pred in o:\n box = pred[:4]\n w = (box[2] - box[0]) / width\n h = (box[3] - box[1]) / height\n x = box[0] / width + w / 2\n y = box[1] / height + h / 2\n conf = pred[4]\n cls = int(pred[5])\n\n targets.append([i, cls, x, y, w, h, conf])\n\n return np.array(targets)","def output_to_target(output, width, height):\n if isinstance(output, torch.Tensor):\n output = output.cpu().numpy()\n\n targets = []\n for i, o in enumerate(output):\n if o is not None:\n for pred in o:\n box = pred[:4]\n w = (box[2] - box[0]) / width\n h = (box[3] - box[1]) / height\n x = box[0] / width + w / 2\n y = box[1] / height + h / 2\n conf = pred[4]\n cls = int(pred[5])\n\n targets.append([i, cls, x, y, w, h, conf])\n\n return np.array(targets)","def hittable_targets(self):\n return [self.current_level.getPlayer()]","def _list_outputs(self):\n \n outputs = self._outputs().get()\n return outputs","def populate_targets(prog):\n #proto = []\n #for b in prog.args.inputs:\n # for a in b:\n # if a not in proto:\n # proto += [ a ]\n for p in prog.args.inputs:\n t = Prog.Target(p.cert)\n tlsa = Prog.Tlsa(p.params, None, None, None)\n tlsa.publish = False\n # hack the tlsa.publish member to mean that the Tlsa object\n # corresponds to a specific record, as opposed to one set\n # by the config file, where tlsa.publish is set to 'True'.\n t.tlsa += [ tlsa ]\n prog.target_list += [ t ]\n return Prog.RetVal.ok","def get_targets(\n self, gt_match_indices: List[Tensor],\n key_sampling_results: List[SamplingResult],\n ref_sampling_results: List[SamplingResult]) -> Tuple[List, List]:\n\n track_targets = []\n track_weights = []\n for _gt_match_indices, key_res, ref_res in zip(gt_match_indices,\n key_sampling_results,\n ref_sampling_results):\n targets = _gt_match_indices.new_zeros(\n (key_res.pos_bboxes.size(0), ref_res.bboxes.size(0)),\n dtype=torch.int)\n _match_indices = _gt_match_indices[key_res.pos_assigned_gt_inds]\n pos2pos = (_match_indices.view(\n -1, 1) == ref_res.pos_assigned_gt_inds.view(1, -1)).int()\n targets[:, :pos2pos.size(1)] = pos2pos\n weights = (targets.sum(dim=1) > 0).float()\n track_targets.append(targets)\n track_weights.append(weights)\n return track_targets, track_weights","def _setTargetNames(self):\n\n # full target names\n if (self.dataStream == 0):\n self.targetNames = np.array(['Clear Night', 'Sunny Day', 'Partly cloudy (night)', 'Partly cloudy (day)',\\\n 'Not used', 'Mist', 'Fog', 'Cloudy', 'Overcast', 'Light rain shower (night)', \\\n 'Light rain shower (day)', 'Drizzle', 'Light rain', 'Heavy rain shower (night)', \\\n 'Heavy rain shower (day)', 'Heavy rain', 'Sleet shower (night)', 'Sleet shower (day)', \\\n 'Sleet', 'Hail shower (night)', 'Hail shower (day)', 'Hail', 'Light snow shower (night)', \\\n 'Light snow shower (day)', 'Light snow', 'Heavy snow shower (night)', 'Heavy snow shower (day)', \\\n 'Heavy snow', 'Thunder shower', 'Thunder shower (night)', 'Thunder'])\n\n # main target names\n elif (self.dataStream == 1):\n self.targetNames = np.array(['Clear', 'Partly Cloudy', 'Mist', 'Fog', 'Cloudy', \\\n 'Overcast', 'Rain', 'Sleet', 'Hail', 'Snow', 'Thunder'])\n\n # basic target names\n elif (self.dataStream == 2):\n self.targetNames = np.array(['Clear', 'Cloudy', 'Precipitation'])\n\n return 0","def get_targets(ode, name, user_targets, control_rates=False):\n if isinstance(ode, dict):\n ode_inputs = ode\n else:\n ode_inputs = get_promoted_vars(ode, iotypes=('input',))\n if user_targets is _unspecified:\n if name in ode_inputs and control_rates not in {1, 2}:\n return [name]\n elif control_rates == 1 and f'{name}_rate' in ode_inputs:\n return [f'{name}_rate']\n elif control_rates == 2 and f'{name}_rate2' in ode_inputs:\n return [f'{name}_rate2']\n elif user_targets:\n if isinstance(user_targets, str):\n return [user_targets]\n else:\n return user_targets\n\n return []","def sample(self,\n data: Sequence[Sequence[torch.Tensor]],\n n_epochs: int = 1) -> Tuple[List[List[int]], List[List[int]], List[int]]:\n\n all_queries = []\n all_targets = []\n for q, t in data:\n all_queries.append(q)\n all_targets.append(t)\n\n print(f'sampler size: {len(all_queries)}')\n\n\n self.n_batch = int(np.ceil(data.__len__() / self.batch_size))\n print(\"n_batch:\", self.n_batch)\n\n for i in range(self.n_batch):\n # position = i * self.batch_size\n # queries = all_queries[position:position + self.batch_size]\n # targets = all_targets[position:position + self.batch_size]\n sample_index = np.random.choice(len(all_queries), self.batch_size)\n queries = [all_queries[i] for i in sample_index]\n targets_label = [all_targets[i] for i in sample_index]\n\n # targets = self.transform_label(targets_label)\n\n # labels = np.arange(len(queries))\n\n # queriess = np.array(queries)\n all_targets_text = self.all_targets\n queries = pad_sequence(queries, batch_first=self.batch_first, padding_value=0)\n\n # targets, queries, labels = torch.tensor(targets), torch.tensor(labels)\n # print(queries[:5])\n # print(len(all_targets_text))\n\n\n targets_label = torch.tensor(targets_label)\n yield (queries, all_targets_text, targets_label)","def _get_sample(self):\n return [layer._get_sample() for layer in self.layers]","def get_targets(\n self,\n anchor_list,\n valid_flag_list,\n gt_bboxes_list,\n img_metas,\n gt_bboxes_ignore_list=None,\n gt_labels_list=None,\n label_channels=1,\n unmap_outputs=True,\n ):\n\n num_imgs = len(img_metas)\n assert len(anchor_list) == len(valid_flag_list) == num_imgs\n concat_anchor_list = []\n concat_valid_flag_list = []\n for i in range(num_imgs):\n assert len(anchor_list[i]) == len(valid_flag_list[i])\n concat_anchor_list.append(torch.cat(anchor_list[i]))\n concat_valid_flag_list.append(torch.cat(valid_flag_list[i]))\n\n # compute targets for each image\n if gt_bboxes_ignore_list is None:\n gt_bboxes_ignore_list = [None for _ in range(num_imgs)]\n if gt_labels_list is None:\n gt_labels_list = [None for _ in range(num_imgs)]\n results = multi_apply(\n self._get_targets_single,\n concat_anchor_list,\n concat_valid_flag_list,\n gt_bboxes_list,\n gt_bboxes_ignore_list,\n gt_labels_list,\n img_metas,\n label_channels=label_channels,\n unmap_outputs=unmap_outputs)\n\n (labels, label_weights, bbox_targets, bbox_weights, valid_pos_inds,\n valid_neg_inds, sampling_result) = results\n\n # Due to valid flag of anchors, we have to calculate the real pos_inds\n # in origin anchor set.\n pos_inds = []\n for i, single_labels in enumerate(labels):\n pos_mask = (0 <= single_labels) & (\n single_labels < self.num_classes)\n pos_inds.append(pos_mask.nonzero().view(-1))\n\n gt_inds = [item.pos_assigned_gt_inds for item in sampling_result]\n return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,\n gt_inds)","def targets_of_neuron(pos, is_excitatory, synapses, network_info):\n\n id = helper.position_to_id(pos, is_excitatory, network_info)\n\n post_ids = synapses[synapses.pre == id].post.values\n\n return _synapse_endpoint_density(post_ids, network_info)"],"string":"[\n \"def get_targets(self):\\n\\t\\treturn self.prDoc['inputs']['data'][0]['targets']\",\n \"def output_targets(self, input_targets):\\n return input_targets\",\n \"def output_targets(self) -> Set[str]:\\n return {\\n out.target\\n for out in\\n self.outputs\\n }\",\n \"def output_targets(self, input_targets):\\n pass\",\n \"def get_targets(self):\\n\\t\\n\\t\\tself.target = []\\n\\t\\ttarget_ins = self.settings['target']\\n\\t\\tfor key in target_ins.keys():\\n\\t\\t\\tif key == 'raw':\\n\\t\\t\\t\\tself.target.append(target_ins[key])\\n\\t\\t\\telif key == 'textfile':\\n\\t\\t\\t\\twith open(target_ins[key],'r') as fp: targs = fp.readlines()\\n\\t\\t\\t\\tfor t in targs:\\n\\t\\t\\t\\t\\tif re.match('^[a-z,A-Z,_].+\\\\s*:\\\\s*[A-Z].+$',t):\\n\\t\\t\\t\\t\\t\\tself.target.append(tuple([i.strip() for i in t.split(':')]))\\n\\t\\t\\telif key == 'textfile_rna':\\n\\t\\t\\t\\twith open(target_ins[key],'r') as fp: targs = fp.readlines()\\n\\t\\t\\t\\tfor t in targs:\\n\\t\\t\\t\\t\\tif re.match('^[a-z,A-Z,0-9,_].+\\\\s*:\\\\s*[A-Z,a-z].+$',t):\\n\\t\\t\\t\\t\\t\\tself.target.append(list([i.strip() for i in t.split(':')]))\\n\\t\\t\\t\\t\\t\\trnaseq = self.target[-1][1]\\n\\t\\t\\t\\t\\t\\t#---extra substitutions for later\\n\\t\\t\\t\\t\\t\\tif 'regex_subs' in self.settings.keys():\\n\\t\\t\\t\\t\\t\\t\\tfor regex in self.settings['regex_subs']:\\n\\t\\t\\t\\t\\t\\t\\t\\trnaseq = re.sub(regex[0],regex[1],rnaseq)\\n\\t\\t\\t\\t\\t\\trnaseq = rnaseq.upper()\\n\\t\\t\\t\\t\\t\\trnaseq = re.sub('T','U',rnaseq)\\n\\t\\t\\t\\t\\t\\taminoseq = ''.join([dna_mapping[i] for i in [rnaseq[i:i+3] \\n\\t\\t\\t\\t\\t\\t\\tfor i in range(0,len(rnaseq),3)]])\\n\\t\\t\\t\\t\\t\\tself.target[-1][1] = re.sub('T','U',aminoseq)\\n\\t\\t\\t\\t\\t\\tself.target[-1] = tuple(self.target[-1])\\n\\t\\t\\telse: raise Exception('except: unclear target type')\",\n \"def _get_targets(input_: Optional[Collection],\\n all_: Collection[Any],\\n type_: str,\\n ) -> Collection[Any]:\\n if input_ is None:\\n return all_\\n target = []\\n for item in input_:\\n if item not in all_:\\n logger.warning(f'unknown target {type_}: {item}')\\n continue\\n target.append(item)\\n return target\",\n \"def collectTargets(self, output):\\n pass\",\n \"def get_targets(self, data_samples: List[TextDetDataSample]) -> Tuple:\\n\\n # If data_samples points to same object as self.cached_data_samples, it\\n # means that get_targets is called more than once in the same train\\n # iteration, and pre-computed targets can be reused.\\n if hasattr(self, 'targets') and \\\\\\n self.cache_data_samples is data_samples:\\n return self.targets\\n\\n self.cache_data_samples = data_samples\\n self.targets = multi_apply(self._get_target_single, data_samples)\\n return self.targets\",\n \"def GetTargets(self):\\n return []\",\n \"def ProduceTargets(self):\\n\\n if self.completion_wanted:\\n return self._FindTarget()\\n else:\\n return []\",\n \"def Targets(self):\\n return self._targets\",\n \"def getBatchOutputs(self, src, net):\\n pass\",\n \"def targets(self) -> List[List[float]]:\\n return [d.targets for d in self.data]\",\n \"def get_targets(self, sort_by_dependency = False):\\n\\t\\treturn self.__targets.get_targets(sort_by_dependency)\",\n \"def get_targets() -> Generator[dict, dict, list[TargetInfo]]:\\n response = yield {\\\"method\\\": \\\"Target.getTargets\\\", \\\"params\\\": {}}\\n return [TargetInfo.from_json(t) for t in response[\\\"targetInfos\\\"]]\",\n \"def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContactTargetsArgs']]]]:\\n return pulumi.get(self, \\\"targets\\\")\",\n \"def targets(self) -> Optional[Union[np.ndarray, Dict[str, np.ndarray]]]:\\n return self._targets\",\n \"def _get_inputs_targets(self, batch):\\n return batch['lr_img'], batch['hr_img']\",\n \"def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PlanTargetsArgs']]]]:\\n return pulumi.get(self, \\\"targets\\\")\",\n \"def _get_batch_targets(self, batch):\\n try:\\n return np.array(self._target_encoder.transform(batch))\\n except AttributeError:\\n return np.array(self._target_encoder(batch))\",\n \"def targets(self) -> Optional[jnp.ndarray]:\\n pass\",\n \"def get_targets():\\n # Use a list comp because querying MODM with Guid.find(Q('referent', 'eq', None))\\n # only catches the first case.\\n return [each for each in Guid.find() if each.referent is None]\",\n \"def load_targets(self, sample_id):\\n\\n objects = self.get_label(sample_id)\\n labels, noObjectLabels = kitti_bev_utils.read_labels_for_bevbox(objects)\\n # on image space: targets are formatted as (class, x, y, w, l, sin(yaw), cos(yaw))\\n targets = kitti_bev_utils.build_yolo_target(labels)\\n\\n return targets\",\n \"def targets(self) -> List[Point2]:\\n return self._targets\",\n \"def targets(self):\\n if self._targets is None:\\n if self.verbose:\\n print('Building targets from coco dataset')\\n cacher = self._cacher('targets')\\n _targets = cacher.tryload(on_error='clear')\\n if _targets is None:\\n _targets = tabular_coco_targets(self.dset)\\n cacher.save(_targets)\\n self._targets = _targets\\n return self._targets\",\n \"def targets(self):\\n\\n return [get_target_by_id(i) for i in self._target_ids]\",\n \"def _get_targets(self, test_id):\\n if isinstance(test_id, BGC) or isinstance(test_id, GCF): # genome side\\n return self._get_targets_genomics(test_id)\\n else: # metabolome side\\n return self._get_targets_metabolomics(test_id)\",\n \"def targets(self) -> Tensor:\\n data_normalized = self._dataset_values.clone()\\n data_normalized -= self._row_min\\n data_normalized /= self._row_range\\n _, outputs_normalized_transformed = self._transform(\\n data_normalized[:, self._input_column_indices],\\n data_normalized[:, self._output_column_indices],\\n )\\n assert outputs_normalized_transformed.ndim == 1 or (\\n outputs_normalized_transformed.ndim == 2\\n and outputs_normalized_transformed.size(1) == 1\\n ), \\\".targets requires exactly one output column (to match TorchVision datasets).\\\"\\n return outputs_normalized_transformed.view(-1).clone()\",\n \"def console_output(self, targets):\\r\\n target_types = {}\\r\\n for target_type in SourceRoot._ROOTS_BY_TYPE.keys():\\r\\n target_types[target_type.__name__] = target_type\\r\\n\\r\\n if self.context.options.goal_targets_details is None:\\r\\n return self._get_installed_targets(target_types)\\r\\n else:\\r\\n return self._get_details(target_types[self.ALIAS_TO_TARGET[self.context.options.goal_targets_details]])\",\n \"def get_all_targets():\\n\\n json_data = gtop.get_json_from_gtop(\\\"targets\\\")\\n return [Target(t) for t in json_data]\",\n \"def get_targets(\\n self, source: Tuple[str, str], relation: Optional[str] = None\\n ) -> List[Node]:\\n return self.get_common_targets([source], relation)\",\n \"def get_target_ports(self):\\n return self.targets\",\n \"def getResult(targets, i=None):\",\n \"def targets(self, predicate=None):\\r\\n return filter(predicate, self._targets)\",\n \"def build_targets(self, patterns):\\n _targets = []\\n for p in patterns:\\n p = p.format_map(self.config)\\n for s in self.samples:\\n e = dict(s, **self.config)\\n _targets.append(p.format_map(e))\\n return list(set(_targets))\",\n \"def get_targets(self, group_set, target_set=[]):\\r\\n result_id = []\\r\\n if not isinstance(group_set, list):\\r\\n for target in self._db(self._db.target).select():\\r\\n result_id.append(target.id)\\r\\n else:\\r\\n rows = self._db(self._db.targetgroup).select()\\r\\n for row in rows:\\r\\n if row.id in group_set:\\r\\n targets = json.loads(row.targets)\\r\\n for t_id in targets:\\r\\n result_id.append(self._db(self._db.target.id==t_id\\r\\n ).select().first().id)\\r\\n result_id += target_set\\r\\n\\r\\n result = []\\r\\n for target_id in set(result_id):\\r\\n result.append(self.get_target(target_id))\\r\\n\\r\\n return result\",\n \"def getTargets():\\n cams = CAMS\\n for cam in cams:\\n\\n cam.resetTargets()\\n cam.resetSizes()\\n image = cam.getImage()\\n print(\\\"Time before getting enemies: \\\" + str(time.time()))\\n bloons, sizes = Vision_Processing.GetBalloon.getEnemies(image)\\n print(\\\"Time after getting enemies: \\\" + str(time.time()))\\n\\n # print \\\"getTargets\\\"\\n # print bloons\\n\\n points = []\\n for bloon in bloons:\\n points.append(np.array([bloon[0], bloon[1]]))\\n for i in range(len(bloons)):\\n cam.addTarget(points[i])\\n cam.addSize(sizes[i])\\n\\n targets = triangulate()\\n print(\\\"Time after triangulation: \\\" + str(time.time()))\\n print \\\"getTargets\\\"\\n print targets\\n # targets = cartesianToSpheric(targets, place, orientation)\\n return targets\",\n \"def sample(self, net, numSamples=None):\\n\\n if numSamples is None:\\n numSamples = self.numSamples\\n\\n\\n if net.is_generator:\\n\\n configs = self._get_samples_gen(net, numSamples)\\n\\n return configs, net(configs), None\\n\\n\\n configs, logPsi = self._get_samples_mcmc(net, numSamples)\\n\\n return configs, logPsi, None\",\n \"def targets(self):\\n\\n\\t\\tstatus, targets = self.execute(self.mission, 'target_list', self.kingdom)\\n\\n\\t\\t# Nothing specified : default is everyone but me.\\n\\t\\tif targets == self:\\n\\t\\t\\ttargets = Kingdom.objects.exclude(id=self.kingdom_id)\\n\\t\\t\\n\\t\\t# Pre-fetch user, for direct access to kingdom name.\\n\\t\\tif isinstance(targets, QuerySet):\\n\\t\\t\\ttargets = targets.select_related('user')\\n\\n\\t\\treturn targets\",\n \"def gather(self, outputs, target_device=None, dim=0):\\n if not self.configer.get('network', 'gathered'):\\n if target_device is None:\\n target_device = list(range(torch.cuda.device_count()))[0]\\n\\n return torch_gather(outputs, target_device, dim=dim)\\n\\n else:\\n return outputs\",\n \"def __call__(self, images, targets):\\n return images, targets\",\n \"def get_extraction_target(inputs, outputs, to_extract, **loss_params):\\n names = [[x.name for x in op.values()] for op in tf.get_default_graph().get_operations()]\\n names = [y for x in names for y in x]\\n\\n r = re.compile(r'__GPU\\\\d__/')\\n _targets = defaultdict(list)\\n\\n for name in names:\\n name_without_gpu_prefix = r.sub('', name)\\n for save_name, actual_name in to_extract.items():\\n if actual_name in name_without_gpu_prefix:\\n tensor = tf.get_default_graph().get_tensor_by_name(name)\\n _targets[save_name].append(tensor)\\n\\n targets = {k: tf.concat(v, axis=0) for k, v in _targets.items()}\\n targets['loss'] = utils.get_loss(inputs, outputs, **loss_params)\\n return targets\",\n \"def get_for_target(self, target):\\n return self.get_for_targets([target])\",\n \"def get_input(data):\\n images, targets = data\\n images = images.cuda()\\n targets = [ann.cuda() for ann in targets]\\n return images, targets\",\n \"def targets(self, spec):\\n\\n spec_parser = CmdLineSpecParser(self.build_root, self.address_mapper)\\n addresses = list(spec_parser.parse_addresses(spec))\\n for address in addresses:\\n self.build_graph.inject_address_closure(address)\\n targets = [self.build_graph.get_target(address) for address in addresses]\\n return targets\",\n \"def targets(self): # type: () -> t.List[HostConfig]\\n return self.host_settings.targets\",\n \"def get_targets(conf):\\r\\n return [oslo.messaging.Target(topic=topic,\\r\\n exchange=conf.glance_control_exchange)\\r\\n for topic in conf.notification_topics]\",\n \"def get_outputs(step):\\n params = step.get('parameters', {})\\n outputs = params.get('outputs', [])\\n for single_output in ['output', 'src_output', 'tgt_output']:\\n if single_output in params:\\n outputs.append(params[single_output])\\n return outputs\",\n \"def get_outputs(self):\\n return self.outputs\",\n \"def get_all_targets(self):\\n return dict(self._targets)\",\n \"def get_outputs(self):\\n return [x[1] for x in self.io_mapping]\",\n \"def make_targets(tgt_re, samples, target_suffix=\\\"\\\"):\\n tgts = list(set(tgt_re.fmt.format(**unit) + target_suffix for unit in samples))\\n return tgts\",\n \"def GetRunTargets(self):\\n return list(self._run_target_index.keys())\",\n \"def get_outputs(self):\\n raise NotImplementedError\",\n \"def get_targets(self, rois: Tensor, rel_roi_points: Tensor,\\n sampling_results: List[SamplingResult],\\n batch_gt_instances: InstanceList,\\n cfg: ConfigType) -> Tensor:\\n\\n num_imgs = len(sampling_results)\\n rois_list = []\\n rel_roi_points_list = []\\n for batch_ind in range(num_imgs):\\n inds = (rois[:, 0] == batch_ind)\\n rois_list.append(rois[inds])\\n rel_roi_points_list.append(rel_roi_points[inds])\\n pos_assigned_gt_inds_list = [\\n res.pos_assigned_gt_inds for res in sampling_results\\n ]\\n cfg_list = [cfg for _ in range(num_imgs)]\\n\\n point_targets = map(self._get_targets_single, rois_list,\\n rel_roi_points_list, pos_assigned_gt_inds_list,\\n batch_gt_instances, cfg_list)\\n point_targets = list(point_targets)\\n\\n if len(point_targets) > 0:\\n point_targets = torch.cat(point_targets)\\n\\n return point_targets\",\n \"def _compute_targets_pytorch(self, ex_rois, gt_rois):\\n\\n assert ex_rois.size(1) == gt_rois.size(1)\\n assert ex_rois.size(2) == 4\\n assert gt_rois.size(2) == 4\\n\\n batch_size = ex_rois.size(0)\\n rois_per_image = ex_rois.size(1)\\n\\n targets = bbox_transform_batch(ex_rois, gt_rois)\\n\\n if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:\\n # Optionally normalize targets by a precomputed mean and stdev\\n targets = ((targets - self.BBOX_NORMALIZE_MEANS.expand_as(targets))\\n / self.BBOX_NORMALIZE_STDS.expand_as(targets))\\n\\n return targets\",\n \"def _compute_targets_pytorch(self, ex_rois, gt_rois):\\n\\n assert ex_rois.size(1) == gt_rois.size(1)\\n assert ex_rois.size(2) == 4\\n assert gt_rois.size(2) == 4\\n\\n batch_size = ex_rois.size(0)\\n rois_per_image = ex_rois.size(1)\\n\\n targets = bbox_transform_batch(ex_rois, gt_rois)\\n\\n if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:\\n # Optionally normalize targets by a precomputed mean and stdev\\n targets = ((targets - self.BBOX_NORMALIZE_MEANS.expand_as(targets))\\n / self.BBOX_NORMALIZE_STDS.expand_as(targets))\\n\\n return targets\",\n \"def get_targets(self, points: List[Tensor],\\n batch_gt_instances_3d: InstanceList) -> Tuple[Tensor]:\\n gt_labels_3d = [\\n instances.labels_3d for instances in batch_gt_instances_3d\\n ]\\n gt_bboxes_3d = [\\n instances.bboxes_3d for instances in batch_gt_instances_3d\\n ]\\n\\n (bbox_targets, mask_targets, positive_mask, negative_mask,\\n point_targets) = multi_apply(self.get_targets_single, points,\\n gt_bboxes_3d, gt_labels_3d)\\n\\n bbox_targets = torch.stack(bbox_targets)\\n mask_targets = torch.stack(mask_targets)\\n positive_mask = torch.stack(positive_mask)\\n negative_mask = torch.stack(negative_mask)\\n box_loss_weights = positive_mask / (positive_mask.sum() + 1e-6)\\n\\n return (bbox_targets, mask_targets, positive_mask, negative_mask,\\n box_loss_weights, point_targets)\",\n \"def all_targets(self):\\n return self._combined_all_versioned_targets.targets\",\n \"def get_outputs(self):\\n return self.attributes[\\\"outputs\\\"]\",\n \"def targets(self):\\n ret = {}\\n for device in self.devices:\\n ret[device.name] = device.name\\n return ret\",\n \"def targets(self) -> List[List[float]]:\\n if self.preload:\\n return [[j[QM9.U0].item()] for j in self.data_ram] # if data_ram is a array of dicts\\n # return self.data_ram[QM9.U0].numpy() # if data_ram is a dict of arrays\\n else:\\n return [[j[QM9.U0].item()] for j in self.data]\",\n \"def get_el_targets(params):\\n data = queryDevice.queryDevice(\\\"\\\"\\\"\\n SELECT DISTINCT dc.tid, dc.target_type, dc.dc, COUNT(DISTINCT act.assay_id), COUNT(DISTINCT activity_id)\\n FROM assays ass\\n JOIN(\\n SELECT td.tid, td.target_type, COUNT(cd.domain_id) as dc\\n FROM target_dictionary td\\n JOIN target_components tc\\n ON tc.tid = td.tid\\n\\t\\t JOIN component_sequences cs\\n\\t\\t\\tON cs.component_id = tc.component_id\\n JOIN component_domains cd\\n \\t\\t\\tON cd.component_id = cs.component_id\\n WHERE td.target_type IN('SINGLE PROTEIN', 'PROTEIN COMPLEX')\\n GROUP BY td.tid\\n ) as dc\\n ON dc.tid = ass.tid\\n JOIN activities act\\n ON act.assay_id = ass.assay_id\\n WHERE act.standard_type IN('Ki','Kd','IC50','EC50', 'AC50')\\n AND ass.relationship_type = 'D'\\n AND assay_type IN('B')\\n AND act.standard_relation IN('=')\\n AND standard_units = 'nM'\\n AND standard_value <= %s\\n GROUP BY dc.tid ORDER BY COUNT(activity_id)\\\"\\\"\\\" % (int(params['threshold']) * 1000) , params)\\n print \\\"retrieved data for \\\", len(data), \\\"tids.\\\"\\n return data\",\n \"def get_target(self):\\n self.target = []\\n for tags in self.cfg.target.split(\\\",\\\"):\\n t = tags.split(\\\"=\\\")\\n self.target.append({\\\"Key\\\": t[0], \\\"Values\\\": [t[1]]})\\n\\n return self.target\",\n \"def get_targets(self,\\n cls_scores_list,\\n bbox_preds_list,\\n gt_bboxes_list,\\n gt_labels_list,\\n gt_bboxes_ignore_list=None):\\n assert gt_bboxes_ignore_list is None, \\\\\\n 'Only supports for gt_bboxes_ignore setting to None.'\\n num_imgs = len(cls_scores_list)\\n gt_bboxes_ignore_list = [\\n gt_bboxes_ignore_list for _ in range(num_imgs)\\n ]\\n\\n (labels_list, label_weights_list, bbox_targets_list,\\n bbox_weights_list, pos_inds_list, neg_inds_list) = multi_apply(\\n self._get_target_single, cls_scores_list, bbox_preds_list,\\n gt_labels_list, gt_bboxes_list, gt_bboxes_ignore_list)\\n num_total_pos = sum((inds.numel() for inds in pos_inds_list))\\n num_total_neg = sum((inds.numel() for inds in neg_inds_list))\\n return (labels_list, label_weights_list, bbox_targets_list,\\n bbox_weights_list, num_total_pos, num_total_neg)\",\n \"def target(self, example):\\n return example[self.target_index]\",\n \"def get_targets(self, df):\\n return df.iloc[:, self.target_col]\",\n \"def only_targets(self, target_type): # type: (t.Type[THostConfig]) -> t.List[THostConfig]\\n if not self.targets:\\n raise Exception('There must be one or more targets.')\\n\\n assert type_guard(self.targets, target_type)\\n\\n return t.cast(t.List[THostConfig], self.targets)\",\n \"def targets(obj, reftype):\",\n \"def get_targets(units, basename, outdir, extensions = ['_fastqc.zip','_fastqc.html','.trim_fastqc.zip','.trim_fastqc.html'], se_ext = ['se'], pe_ext = ['1','2']):\\n fastqc_targs = []\\n for s, u in units.iterrows():\\n sample, unit = u['sample'],u['unit']\\n end = se_ext if is_se(units,sample,unit) else pe_ext\\n fastqc_targs = fastqc_targs + ['{}_{}_'.format(sample,unit) + i + j for i in end for j in extensions]\\n return [path.join(outdir, targ) for targ in fastqc_targs]\",\n \"def compute_loc_targets(boxes, gt_boxes, weights=(1.0, 1.0, 1.0, 1.0)):\\r\\n ex_widths = boxes[:, 2] - boxes[:, 0] + 1.0\\r\\n ex_heights = boxes[:, 3] - boxes[:, 1] + 1.0\\r\\n ex_ctr_x = boxes[:, 0] + 0.5 * ex_widths\\r\\n ex_ctr_y = boxes[:, 1] + 0.5 * ex_heights\\r\\n\\r\\n gt_widths = gt_boxes[:, 2] - gt_boxes[:, 0] + 1.0\\r\\n gt_heights = gt_boxes[:, 3] - gt_boxes[:, 1] + 1.0\\r\\n gt_ctr_x = gt_boxes[:, 0] + 0.5 * gt_widths\\r\\n gt_ctr_y = gt_boxes[:, 1] + 0.5 * gt_heights\\r\\n\\r\\n wx, wy, ww, wh = weights\\r\\n targets_dx = wx * (gt_ctr_x - ex_ctr_x) / ex_widths\\r\\n targets_dy = wy * (gt_ctr_y - ex_ctr_y) / ex_heights\\r\\n targets_dw = ww * np.log(gt_widths / ex_widths)\\r\\n targets_dh = wh * np.log(gt_heights / ex_heights)\\r\\n\\r\\n targets = np.vstack((targets_dx, targets_dy, targets_dw,\\r\\n targets_dh)).transpose()\\r\\n return targets\",\n \"def MakeSamplesFromOutput(metadata, output, use_tpu=False, model=RESNET):\\n samples = []\\n if RESNET in model:\\n results = regex_util.ExtractAllMatches(\\n f'Speed: ({RE_FLOAT}) samples/sec', output)\\n results.extend(regex_util.ExtractAllMatches(\\n f'\\\"imgs_sec\\\": ({RE_FLOAT})', output))\\n results.extend(regex_util.ExtractAllMatches(\\n f'\\\"key\\\": \\\"throughput\\\", \\\"value\\\": ({RE_FLOAT})', output))\\n elif TRANSFORMER in model:\\n results = re.findall(r'wps=(\\\\S+),', output)\\n elif GNMT in model:\\n results = re.findall(r'Tok/s (\\\\S+)', output)\\n elif SSD in model:\\n results = re.findall(r'avg. samples / sec: (\\\\S+)', output)\\n elif MASK in model:\\n results = regex_util.ExtractAllMatches(\\n f'\\\"throughput\\\": ({RE_FLOAT})', output)\\n results.extend(regex_util.ExtractAllMatches(\\n f'\\\"key\\\": \\\"throughput\\\", \\\"value\\\": ({RE_FLOAT})', output))\\n results.extend(regex_util.ExtractAllMatches(\\n f'MLPERF METRIC THROUGHPUT=({RE_FLOAT}) iterations / s', output))\\n elif BERT in model:\\n results = regex_util.ExtractAllMatches(\\n f\\\"'training_sequences_per_second': ({RE_FLOAT})\\\", output)\\n for speed in results:\\n samples.append(sample.Sample('speed', float(speed), 'samples/sec',\\n metadata))\\n\\n if not use_tpu:\\n if MINIGO in model:\\n times = regex_util.ExtractAllMatches(r'RESULT,.*,(\\\\d+),.*,.*', output)\\n else:\\n times = regex_util.ExtractAllMatches(r'RESULT,.*,.*,(\\\\d+),.*,.*', output)\\n samples.append(sample.Sample('Time', int(times[0]), 'seconds', metadata))\\n\\n samples.extend(MakeMLPerfSamplesFromOutput(metadata, output))\\n return samples\",\n \"def get_target(self):\\n rospy.init_node('bot_control', anonymous=True)\\n\\n rospy.Subscriber('/predict_target', Float32MultiArray, self.callback)\\n rospy.spin()\",\n \"def __get_potential_targets(self):\\n network_targets = {}\\n for network in self.__get_scanning_range():\\n ips = IPNetwork(network) # converts CIRD notation to IP addresses\\n targets = []\\n for ip in ips:\\n targets.append(ip)\\n print(\\\"Potential targets on {} network: {}\\\".format(network, len(targets)))\\n network_targets.update({network: targets})\\n return network_targets\",\n \"def getMarkedTargets(markup):\\n targets = markup.getConTextModeNodes(\\\"target\\\")\\n targets.sort()\\n return targets\",\n \"def get_targets(self,\\n anchor_list: List[List[Tensor]],\\n valid_flag_list: List[List[Tensor]],\\n batch_gt_instances: InstanceList,\\n batch_img_metas: List[dict],\\n batch_gt_instances_ignore: OptInstanceList = None,\\n unmap_outputs: bool = True) -> tuple:\\n num_imgs = len(batch_img_metas)\\n assert len(anchor_list) == len(valid_flag_list) == num_imgs\\n\\n # anchor number of multi levels\\n num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]\\n num_level_anchors_list = [num_level_anchors] * num_imgs\\n\\n # concat all level anchors and flags to a single tensor\\n for i in range(num_imgs):\\n assert len(anchor_list[i]) == len(valid_flag_list[i])\\n anchor_list[i] = torch.cat(anchor_list[i])\\n valid_flag_list[i] = torch.cat(valid_flag_list[i])\\n\\n # compute targets for each image\\n if batch_gt_instances_ignore is None:\\n batch_gt_instances_ignore = [None] * num_imgs\\n (all_anchors, all_labels, all_label_weights, all_bbox_targets,\\n all_bbox_weights, pos_inds_list, neg_inds_list,\\n sampling_results_list) = multi_apply(\\n self._get_targets_single,\\n anchor_list,\\n valid_flag_list,\\n num_level_anchors_list,\\n batch_gt_instances,\\n batch_img_metas,\\n batch_gt_instances_ignore,\\n unmap_outputs=unmap_outputs)\\n # Get `avg_factor` of all images, which calculate in `SamplingResult`.\\n # When using sampling method, avg_factor is usually the sum of\\n # positive and negative priors. When using `PseudoSampler`,\\n # `avg_factor` is usually equal to the number of positive priors.\\n avg_factor = sum(\\n [results.avg_factor for results in sampling_results_list])\\n # split targets to a list w.r.t. multiple levels\\n anchors_list = images_to_levels(all_anchors, num_level_anchors)\\n labels_list = images_to_levels(all_labels, num_level_anchors)\\n label_weights_list = images_to_levels(all_label_weights,\\n num_level_anchors)\\n bbox_targets_list = images_to_levels(all_bbox_targets,\\n num_level_anchors)\\n bbox_weights_list = images_to_levels(all_bbox_weights,\\n num_level_anchors)\\n return (anchors_list, labels_list, label_weights_list,\\n bbox_targets_list, bbox_weights_list, avg_factor)\",\n \"def _get_targets_single(self, rois: Tensor, rel_roi_points: Tensor,\\n pos_assigned_gt_inds: Tensor,\\n gt_instances: InstanceData,\\n cfg: ConfigType) -> Tensor:\\n num_pos = rois.size(0)\\n num_points = cfg.num_points\\n if num_pos > 0:\\n gt_masks_th = (\\n gt_instances.masks.to_tensor(rois.dtype,\\n rois.device).index_select(\\n 0, pos_assigned_gt_inds))\\n gt_masks_th = gt_masks_th.unsqueeze(1)\\n rel_img_points = rel_roi_point_to_rel_img_point(\\n rois, rel_roi_points, gt_masks_th)\\n point_targets = point_sample(gt_masks_th,\\n rel_img_points).squeeze(1)\\n else:\\n point_targets = rois.new_zeros((0, num_points))\\n return point_targets\",\n \"def outputs(self):\\n return self.outputs\",\n \"def getTargets(targets) -> str:\\n return\\\"\\\"\\\"## Target\\n| |Category| |Task| Estimated Time | Actual Time |\\n| - | -: | - | - | - | - |\\n{previousTargets}\\\"\\\"\\\".format(previousTargets=targets)\",\n \"def _get_targets_single(self, mask_preds: Tensor,\\n gt_instances: InstanceData,\\n positive_info: InstanceData):\\n gt_bboxes = gt_instances.bboxes\\n device = gt_bboxes.device\\n gt_masks = gt_instances.masks.to_tensor(\\n dtype=torch.bool, device=device).float()\\n\\n # process with mask targets\\n pos_assigned_gt_inds = positive_info.get('pos_assigned_gt_inds')\\n scores = positive_info.get('scores')\\n centernesses = positive_info.get('centernesses')\\n num_pos = pos_assigned_gt_inds.size(0)\\n\\n if gt_masks.size(0) == 0 or num_pos == 0:\\n return mask_preds, None, 0\\n # Since we're producing (near) full image masks,\\n # it'd take too much vram to backprop on every single mask.\\n # Thus we select only a subset.\\n if (self.max_masks_to_train != -1) and \\\\\\n (num_pos > self.max_masks_to_train):\\n perm = torch.randperm(num_pos)\\n select = perm[:self.max_masks_to_train]\\n mask_preds = mask_preds[select]\\n pos_assigned_gt_inds = pos_assigned_gt_inds[select]\\n num_pos = self.max_masks_to_train\\n elif self.topk_masks_per_img != -1:\\n unique_gt_inds = pos_assigned_gt_inds.unique()\\n num_inst_per_gt = max(\\n int(self.topk_masks_per_img / len(unique_gt_inds)), 1)\\n\\n keep_mask_preds = []\\n keep_pos_assigned_gt_inds = []\\n for gt_ind in unique_gt_inds:\\n per_inst_pos_inds = (pos_assigned_gt_inds == gt_ind)\\n mask_preds_per_inst = mask_preds[per_inst_pos_inds]\\n gt_inds_per_inst = pos_assigned_gt_inds[per_inst_pos_inds]\\n if sum(per_inst_pos_inds) > num_inst_per_gt:\\n per_inst_scores = scores[per_inst_pos_inds].sigmoid().max(\\n dim=1)[0]\\n per_inst_centerness = centernesses[\\n per_inst_pos_inds].sigmoid().reshape(-1, )\\n select = (per_inst_scores * per_inst_centerness).topk(\\n k=num_inst_per_gt, dim=0)[1]\\n mask_preds_per_inst = mask_preds_per_inst[select]\\n gt_inds_per_inst = gt_inds_per_inst[select]\\n keep_mask_preds.append(mask_preds_per_inst)\\n keep_pos_assigned_gt_inds.append(gt_inds_per_inst)\\n mask_preds = torch.cat(keep_mask_preds)\\n pos_assigned_gt_inds = torch.cat(keep_pos_assigned_gt_inds)\\n num_pos = pos_assigned_gt_inds.size(0)\\n\\n # Follow the origin implement\\n start = int(self.mask_out_stride // 2)\\n gt_masks = gt_masks[:, start::self.mask_out_stride,\\n start::self.mask_out_stride]\\n gt_masks = gt_masks.gt(0.5).float()\\n pos_mask_targets = gt_masks[pos_assigned_gt_inds]\\n\\n return (mask_preds, pos_mask_targets, num_pos)\",\n \"def outputs(self):\\r\\n return self._outputs\",\n \"def get_ddqn_targets(qsa_target, q_targets, mask, estimator, next_states):\\n with torch.no_grad():\\n next_q_values = estimator(next_states)\\n argmax_actions = next_q_values.max(1, keepdim=True)[1]\\n qsa_target[mask] = q_targets.gather(1, argmax_actions)\\n return qsa_target\",\n \"def find_targetnodes(self):\\n\\n self.connect_backwards()\\n\\n targetnodes = []\\n for n in self.find_datanodes():\\n if len(n.receives_from) > 0:\\n targetnodes.append(n)\\n return targetnodes\",\n \"def get_targets_for_group_key(self, key):\\r\\n\\r\\n return self.key_to_targets[key]\",\n \"def get_next_target_addresses(self) -> List[str]:\\n targets = []\\n for edge in self._get_out_edges(self.active_pod):\\n targets.append(self._get_target_pod(edge.pod).full_address)\\n return targets\",\n \"def read_targets(self):\\n\\n c = self.c\\n\\n new = []\\n name = None\\n\\n for line in c.p.b.split('\\\\n'):\\n\\n if line.startswith('NAME: '):\\n if name is not None:\\n g.es(\\\"Error reading targets, two NAMEs without an UNL between them\\\")\\n return\\n name = line[6:].strip()\\n continue\\n\\n if line.startswith('UNL: '):\\n if name is None:\\n g.es(\\\"Error reading targets, UNL without preceeding NAME\\\")\\n return\\n unl = line[5:].strip()\\n new.append((name, unl))\\n name = None\\n continue\\n\\n # other lines are just ignored\\n\\n g.app.db['_quickmove']['global_targets'] = [\\n {'name': name2, 'unl': unl2} for name2, unl2 in new\\n ]\\n # make sure g.app.db knows it's been changed\\n g.app.db['_quickmove'] = g.app.db['_quickmove']\\n\\n g.es(\\\"%d targets read - you should delete this node now\\\" % len(new))\",\n \"def target_ids(self):\\n\\n return self._target_ids\",\n \"def get_target_tags(self):\\n raise NotImplementedError(\\\"\\\")\",\n \"def output_to_target(output, width, height):\\n if isinstance(output, torch.Tensor):\\n output = output.cpu().numpy()\\n\\n targets = []\\n for i, o in enumerate(output):\\n if o is not None:\\n for pred in o:\\n box = pred[:4]\\n w = (box[2] - box[0]) / width\\n h = (box[3] - box[1]) / height\\n x = box[0] / width + w / 2\\n y = box[1] / height + h / 2\\n conf = pred[4]\\n cls = int(pred[5])\\n\\n targets.append([i, cls, x, y, w, h, conf])\\n\\n return np.array(targets)\",\n \"def output_to_target(output, width, height):\\n if isinstance(output, torch.Tensor):\\n output = output.cpu().numpy()\\n\\n targets = []\\n for i, o in enumerate(output):\\n if o is not None:\\n for pred in o:\\n box = pred[:4]\\n w = (box[2] - box[0]) / width\\n h = (box[3] - box[1]) / height\\n x = box[0] / width + w / 2\\n y = box[1] / height + h / 2\\n conf = pred[4]\\n cls = int(pred[5])\\n\\n targets.append([i, cls, x, y, w, h, conf])\\n\\n return np.array(targets)\",\n \"def hittable_targets(self):\\n return [self.current_level.getPlayer()]\",\n \"def _list_outputs(self):\\n \\n outputs = self._outputs().get()\\n return outputs\",\n \"def populate_targets(prog):\\n #proto = []\\n #for b in prog.args.inputs:\\n # for a in b:\\n # if a not in proto:\\n # proto += [ a ]\\n for p in prog.args.inputs:\\n t = Prog.Target(p.cert)\\n tlsa = Prog.Tlsa(p.params, None, None, None)\\n tlsa.publish = False\\n # hack the tlsa.publish member to mean that the Tlsa object\\n # corresponds to a specific record, as opposed to one set\\n # by the config file, where tlsa.publish is set to 'True'.\\n t.tlsa += [ tlsa ]\\n prog.target_list += [ t ]\\n return Prog.RetVal.ok\",\n \"def get_targets(\\n self, gt_match_indices: List[Tensor],\\n key_sampling_results: List[SamplingResult],\\n ref_sampling_results: List[SamplingResult]) -> Tuple[List, List]:\\n\\n track_targets = []\\n track_weights = []\\n for _gt_match_indices, key_res, ref_res in zip(gt_match_indices,\\n key_sampling_results,\\n ref_sampling_results):\\n targets = _gt_match_indices.new_zeros(\\n (key_res.pos_bboxes.size(0), ref_res.bboxes.size(0)),\\n dtype=torch.int)\\n _match_indices = _gt_match_indices[key_res.pos_assigned_gt_inds]\\n pos2pos = (_match_indices.view(\\n -1, 1) == ref_res.pos_assigned_gt_inds.view(1, -1)).int()\\n targets[:, :pos2pos.size(1)] = pos2pos\\n weights = (targets.sum(dim=1) > 0).float()\\n track_targets.append(targets)\\n track_weights.append(weights)\\n return track_targets, track_weights\",\n \"def _setTargetNames(self):\\n\\n # full target names\\n if (self.dataStream == 0):\\n self.targetNames = np.array(['Clear Night', 'Sunny Day', 'Partly cloudy (night)', 'Partly cloudy (day)',\\\\\\n 'Not used', 'Mist', 'Fog', 'Cloudy', 'Overcast', 'Light rain shower (night)', \\\\\\n 'Light rain shower (day)', 'Drizzle', 'Light rain', 'Heavy rain shower (night)', \\\\\\n 'Heavy rain shower (day)', 'Heavy rain', 'Sleet shower (night)', 'Sleet shower (day)', \\\\\\n 'Sleet', 'Hail shower (night)', 'Hail shower (day)', 'Hail', 'Light snow shower (night)', \\\\\\n 'Light snow shower (day)', 'Light snow', 'Heavy snow shower (night)', 'Heavy snow shower (day)', \\\\\\n 'Heavy snow', 'Thunder shower', 'Thunder shower (night)', 'Thunder'])\\n\\n # main target names\\n elif (self.dataStream == 1):\\n self.targetNames = np.array(['Clear', 'Partly Cloudy', 'Mist', 'Fog', 'Cloudy', \\\\\\n 'Overcast', 'Rain', 'Sleet', 'Hail', 'Snow', 'Thunder'])\\n\\n # basic target names\\n elif (self.dataStream == 2):\\n self.targetNames = np.array(['Clear', 'Cloudy', 'Precipitation'])\\n\\n return 0\",\n \"def get_targets(ode, name, user_targets, control_rates=False):\\n if isinstance(ode, dict):\\n ode_inputs = ode\\n else:\\n ode_inputs = get_promoted_vars(ode, iotypes=('input',))\\n if user_targets is _unspecified:\\n if name in ode_inputs and control_rates not in {1, 2}:\\n return [name]\\n elif control_rates == 1 and f'{name}_rate' in ode_inputs:\\n return [f'{name}_rate']\\n elif control_rates == 2 and f'{name}_rate2' in ode_inputs:\\n return [f'{name}_rate2']\\n elif user_targets:\\n if isinstance(user_targets, str):\\n return [user_targets]\\n else:\\n return user_targets\\n\\n return []\",\n \"def sample(self,\\n data: Sequence[Sequence[torch.Tensor]],\\n n_epochs: int = 1) -> Tuple[List[List[int]], List[List[int]], List[int]]:\\n\\n all_queries = []\\n all_targets = []\\n for q, t in data:\\n all_queries.append(q)\\n all_targets.append(t)\\n\\n print(f'sampler size: {len(all_queries)}')\\n\\n\\n self.n_batch = int(np.ceil(data.__len__() / self.batch_size))\\n print(\\\"n_batch:\\\", self.n_batch)\\n\\n for i in range(self.n_batch):\\n # position = i * self.batch_size\\n # queries = all_queries[position:position + self.batch_size]\\n # targets = all_targets[position:position + self.batch_size]\\n sample_index = np.random.choice(len(all_queries), self.batch_size)\\n queries = [all_queries[i] for i in sample_index]\\n targets_label = [all_targets[i] for i in sample_index]\\n\\n # targets = self.transform_label(targets_label)\\n\\n # labels = np.arange(len(queries))\\n\\n # queriess = np.array(queries)\\n all_targets_text = self.all_targets\\n queries = pad_sequence(queries, batch_first=self.batch_first, padding_value=0)\\n\\n # targets, queries, labels = torch.tensor(targets), torch.tensor(labels)\\n # print(queries[:5])\\n # print(len(all_targets_text))\\n\\n\\n targets_label = torch.tensor(targets_label)\\n yield (queries, all_targets_text, targets_label)\",\n \"def _get_sample(self):\\n return [layer._get_sample() for layer in self.layers]\",\n \"def get_targets(\\n self,\\n anchor_list,\\n valid_flag_list,\\n gt_bboxes_list,\\n img_metas,\\n gt_bboxes_ignore_list=None,\\n gt_labels_list=None,\\n label_channels=1,\\n unmap_outputs=True,\\n ):\\n\\n num_imgs = len(img_metas)\\n assert len(anchor_list) == len(valid_flag_list) == num_imgs\\n concat_anchor_list = []\\n concat_valid_flag_list = []\\n for i in range(num_imgs):\\n assert len(anchor_list[i]) == len(valid_flag_list[i])\\n concat_anchor_list.append(torch.cat(anchor_list[i]))\\n concat_valid_flag_list.append(torch.cat(valid_flag_list[i]))\\n\\n # compute targets for each image\\n if gt_bboxes_ignore_list is None:\\n gt_bboxes_ignore_list = [None for _ in range(num_imgs)]\\n if gt_labels_list is None:\\n gt_labels_list = [None for _ in range(num_imgs)]\\n results = multi_apply(\\n self._get_targets_single,\\n concat_anchor_list,\\n concat_valid_flag_list,\\n gt_bboxes_list,\\n gt_bboxes_ignore_list,\\n gt_labels_list,\\n img_metas,\\n label_channels=label_channels,\\n unmap_outputs=unmap_outputs)\\n\\n (labels, label_weights, bbox_targets, bbox_weights, valid_pos_inds,\\n valid_neg_inds, sampling_result) = results\\n\\n # Due to valid flag of anchors, we have to calculate the real pos_inds\\n # in origin anchor set.\\n pos_inds = []\\n for i, single_labels in enumerate(labels):\\n pos_mask = (0 <= single_labels) & (\\n single_labels < self.num_classes)\\n pos_inds.append(pos_mask.nonzero().view(-1))\\n\\n gt_inds = [item.pos_assigned_gt_inds for item in sampling_result]\\n return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,\\n gt_inds)\",\n \"def targets_of_neuron(pos, is_excitatory, synapses, network_info):\\n\\n id = helper.position_to_id(pos, is_excitatory, network_info)\\n\\n post_ids = synapses[synapses.pre == id].post.values\\n\\n return _synapse_endpoint_density(post_ids, network_info)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7546623","0.71686465","0.6932078","0.6811666","0.6767465","0.67216605","0.6592436","0.65119016","0.65086675","0.6496015","0.6452853","0.64246523","0.6375694","0.63572305","0.632819","0.62846535","0.6282436","0.6256334","0.622767","0.62171936","0.6214964","0.6196159","0.61332065","0.6119204","0.6103048","0.60996914","0.6097129","0.6063171","0.605177","0.5984798","0.5961599","0.59544903","0.5855359","0.58396506","0.5829388","0.5793526","0.5768398","0.5762512","0.5761056","0.57467264","0.5745066","0.5731588","0.57289916","0.5727146","0.5700115","0.569791","0.56963867","0.56920546","0.5687153","0.5682656","0.5680925","0.56364185","0.5632827","0.5621471","0.5616381","0.56115425","0.56115425","0.55865836","0.55847484","0.5543981","0.55431706","0.55353236","0.55206376","0.5511289","0.5509803","0.5508081","0.55005777","0.54927284","0.5487471","0.54835093","0.5479184","0.5473862","0.54573596","0.54557586","0.5451432","0.54479706","0.54451096","0.5443564","0.5437519","0.5436838","0.542958","0.5424573","0.5424456","0.54064363","0.54006046","0.53964984","0.5379639","0.537786","0.5375628","0.5375628","0.53746945","0.53656435","0.5354087","0.5346832","0.5344205","0.534303","0.5338299","0.5332835","0.5332314","0.53155065"],"string":"[\n \"0.7546623\",\n \"0.71686465\",\n \"0.6932078\",\n \"0.6811666\",\n \"0.6767465\",\n \"0.67216605\",\n \"0.6592436\",\n \"0.65119016\",\n \"0.65086675\",\n \"0.6496015\",\n \"0.6452853\",\n \"0.64246523\",\n \"0.6375694\",\n \"0.63572305\",\n \"0.632819\",\n \"0.62846535\",\n \"0.6282436\",\n \"0.6256334\",\n \"0.622767\",\n \"0.62171936\",\n \"0.6214964\",\n \"0.6196159\",\n \"0.61332065\",\n \"0.6119204\",\n \"0.6103048\",\n \"0.60996914\",\n \"0.6097129\",\n \"0.6063171\",\n \"0.605177\",\n \"0.5984798\",\n \"0.5961599\",\n \"0.59544903\",\n \"0.5855359\",\n \"0.58396506\",\n \"0.5829388\",\n \"0.5793526\",\n \"0.5768398\",\n \"0.5762512\",\n \"0.5761056\",\n \"0.57467264\",\n \"0.5745066\",\n \"0.5731588\",\n \"0.57289916\",\n \"0.5727146\",\n \"0.5700115\",\n \"0.569791\",\n \"0.56963867\",\n \"0.56920546\",\n \"0.5687153\",\n \"0.5682656\",\n \"0.5680925\",\n \"0.56364185\",\n \"0.5632827\",\n \"0.5621471\",\n \"0.5616381\",\n \"0.56115425\",\n \"0.56115425\",\n \"0.55865836\",\n \"0.55847484\",\n \"0.5543981\",\n \"0.55431706\",\n \"0.55353236\",\n \"0.55206376\",\n \"0.5511289\",\n \"0.5509803\",\n \"0.5508081\",\n \"0.55005777\",\n \"0.54927284\",\n \"0.5487471\",\n \"0.54835093\",\n \"0.5479184\",\n \"0.5473862\",\n \"0.54573596\",\n \"0.54557586\",\n \"0.5451432\",\n \"0.54479706\",\n \"0.54451096\",\n \"0.5443564\",\n \"0.5437519\",\n \"0.5436838\",\n \"0.542958\",\n \"0.5424573\",\n \"0.5424456\",\n \"0.54064363\",\n \"0.54006046\",\n \"0.53964984\",\n \"0.5379639\",\n \"0.537786\",\n \"0.5375628\",\n \"0.5375628\",\n \"0.53746945\",\n \"0.53656435\",\n \"0.5354087\",\n \"0.5346832\",\n \"0.5344205\",\n \"0.534303\",\n \"0.5338299\",\n \"0.5332835\",\n \"0.5332314\",\n \"0.53155065\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.883374"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23998,"cells":{"query":{"kind":"string","value":"Get normalized probabilities (or log probs) from a net's output."},"document":{"kind":"string","value":"def get_normalized_probs(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]] = None,\n ):\n return self.get_normalized_probs_scriptable(net_output, log_probs, sample)"},"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_normalized_probs(self, net_output, log_probs, sample=None):\n encoder_out = net_output[\"encoder_out\"]\n if torch.is_tensor(encoder_out):\n logits = encoder_out.float()\n if log_probs:\n return F.log_softmax(logits, dim=-1)\n else:\n return F.softmax(logits, dim=-1)\n raise NotImplementedError","def get_normalized_probs(self, net_output, log_probs):\n logits = net_output\n if log_probs:\n return F.log_softmax(logits, dim=1)\n else:\n return F.softmax(logits, dim=1)","def get_normalized_probs(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]],\n ):\n\n if hasattr(self, \"adaptive_softmax\") and self.adaptive_softmax is not None:\n if sample is not None:\n assert \"target\" in sample\n target = sample[\"target\"]\n else:\n target = None\n out = self.adaptive_softmax.get_log_prob(net_output[0], target=target)\n return out.exp_() if not log_probs else out\n\n logits = net_output[0]\n if log_probs:\n return utils.log_softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\n else:\n return utils.softmax(logits, dim=-1, onnx_trace=self.onnx_trace)","def get_normalized_probs(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]] = None,\n ):\n\n if hasattr(self, \"adaptive_softmax\") and self.adaptive_softmax is not None:\n if sample is not None:\n assert \"target\" in sample\n target = sample[\"target\"]\n else:\n target = None\n out = self.adaptive_softmax.get_log_prob(net_output[0], target=target)\n return out.exp_() if not log_probs else out\n\n logits = net_output[0]\n if log_probs:\n return log_softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\n else:\n return softmax(logits, dim=-1, onnx_trace=self.onnx_trace)","def get_normalized_probs_scriptable(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]] = None,\n ):\n if hasattr(self, \"decoder\"):\n return self.decoder.get_normalized_probs(net_output, log_probs, sample)\n elif torch.is_tensor(net_output):\n # syntactic sugar for simple models which don't have a decoder\n # (e.g., the classification tutorial)\n logits = net_output.float()\n if log_probs:\n return F.log_softmax(logits, dim=-1)\n else:\n return F.softmax(logits, dim=-1)\n raise NotImplementedError","def __get_net_probs(self):\n return np.array([node.value for node in self.net]).reshape(5,5)","def log_probs(self):\n return np.array([m['log_probs'] for m in self.model_outs], dtype=np.float32)","def transform_output_probs(self, y, get_prob = False):\n return np.array(self.sample_labels(y,\n num_of_sents = len(y), # all sentences\n num_of_samples = max(map(len, y)), # all words\n num_of_classes = 1, # Only top probability\n start_index = 0, # all sentences\n get_prob = get_prob, # Indicate whether to get only labels\n ))","def transform_output_probs(self, y, get_prob = False):\n return np.array(self.sample_labels(y,\n num_of_sents = len(y), # all sentences\n num_of_samples = max(map(len, y)), # all words\n num_of_classes = 1, # Only top probability\n start_index = 0, # all sentences\n get_prob = get_prob, # Indicate whether to get only labels\n ))","def interpret_output(self, netOutput):\n # Class Conditional Probability: P(class | object),\n # i.e. assuming there is an object in the grid being considered,\n # what is the probability the object belongs to each class\n self.classConditionalProbability = np.reshape(\n netOutput[:, :self.endIndexOfClassConditionalProbability],\n [self.numOfGridsIn1D, self.numOfGridsIn1D, self.numOfClasses]\n )\n if self.debug:\n print(\"classConditionalProbability.\")\n # P(object): Object probability, i.e. the probability of an\n # object in each bounding box in each grid\n self.objectProbability = np.reshape(\n netOutput[\n :,\n self.endIndexOfClassConditionalProbability:\\\n self.endIndexOfObjectProbability\n ],\n [self.numOfGridsIn1D, self.numOfGridsIn1D, self.numOfBoxesPerGrid]\n )\n if self.debug:\n print(\"objectProbability.\")\n # objectClassProbability: P(class | object) * P(object), i.e.\n # the probability of an object present, and it being each class\n # Equivalent to:\n #for i in range(self.numOfBoxesPerGrid):\n # for j in range(self.numOfClasses):\n # self.objectClassProbability[:, :, i, j] = np.multiply(\n # self.objectProbability[:, :, i],\n # self.classConditionalProbability[:, :, j]\n # )\n # Also equivalent to:\n # for i in range(self.numOfGridsIn1D):\n # for j in range(self.numOfGridsIn1D):\n # self.objectClassProbability[i, j] = np.outer(\n # self.objectProbability[i, j, :],\n # self.classConditionalProbability[i, j, :]\n # )\n # Or:\n self.objectClassProbability = np.einsum(\n '...i, ...j',\n self.objectProbability,\n self.classConditionalProbability,\n out=self.objectClassProbability\n )\n if self.debug:\n print(\"objectClassProbability.\")\n # (x, y, w, h) == (<left> <top> <right> <bottom>) of the\n # numOfBoxesPerGrid bounding boxes predicted by the network\n self.boxData = np.reshape(\n netOutput[:, self.endIndexOfObjectProbability:],\n [self.numOfGridsIn1D, self.numOfGridsIn1D, self.numOfBoxesPerGrid, 4]\n )\n # Changing x <left> and y <top> coordinates from within-grid\n # coordinates to image coordinates\n self.boxData[:, :, :, 0] = 1. * \\\n (self.boxData[:, :, :, 0]+self.offsetX) * self.imageWidth \\\n / self.numOfGridsIn1D\n self.boxData[:, :, :, 1] = 1. * \\\n (self.boxData[:, :, :, 1]+self.offsetY) * self.imageHeight \\\n / self.numOfGridsIn1D\n # Changing width and height from model representation to image\n # representation, square root of the width and height is predicted\n # because small error in small boxes matter much more than small errors\n # in large boxes\n self.boxData[:, :, :, 2] = self.imageWidth * np.multiply(\n self.boxData[:, :, :, 2],\n self.boxData[:, :, :, 2]\n )\n self.boxData[:, :, :, 3] = self.imageHeight * np.multiply(\n self.boxData[:, :, :, 3],\n self.boxData[:, :, :, 3]\n )\n if self.debug:\n print(\"boxData.\")\n # Find out the index of the class with maximum probability for\n # every object/bounding box\n self.maxProbableClasses = np.argmax(self.objectClassProbability, axis=3)\n if self.debug:\n print(\"maxProbableClasses.\")\n # Find out the probability value of these max classes\n self.maxProbableClassProbabilities = np.max(\n self.objectClassProbability, axis=3\n )\n if self.debug:\n print(\"maxProbableClassProbabilities.\")\n # Eliminate those objects whose class probabilities are lesser\n # than minClassProbability\n thresholdedClassesIndex = np.where(\n self.maxProbableClassProbabilities >= self.minClassProbability\n )\n if self.debug:\n print(\"thresholdedClassesIndex.\")\n # The classes\n thresholdedClasses = self.maxProbableClasses[thresholdedClassesIndex]\n if self.debug:\n print(\"thresholdedClasses.\")\n # The class probabilities\n thresholdedClassProbabilities = self.maxProbableClassProbabilities[\n thresholdedClassesIndex\n ]\n if self.debug:\n print(\"thresholdedClassProbabilities.\")\n # Find out the boxes corresponding to the filtered objects\n thresholdedBoxes = self.boxData[\n thresholdedClassesIndex[0],\n thresholdedClassesIndex[1],\n thresholdedClassesIndex[2]\n ]\n if self.debug:\n print(\"thresholdedBoxes.\")\n # Sort the boxes and classes based on probabilities\n sortOrder = np.argsort(thresholdedClassProbabilities)[::-1]\n if self.debug:\n print(\"sortOrder.\")\n thresholdedClassProbabilities \\\n = thresholdedClassProbabilities[sortOrder]\n thresholdedBoxes = thresholdedBoxes[sortOrder]\n thresholdedClasses = thresholdedClasses[sortOrder]\n if self.debug:\n print(\"thresholdedClasses.\")\n # Non-maximum supression\n for box1 in range(len(thresholdedClassProbabilities)):\n if thresholdedClassProbabilities[box1] == 0.:\n continue\n for box2 in range(box1 + 1, len(thresholdedClassProbabilities)):\n if self.iou(thresholdedBoxes[box1], thresholdedBoxes[box2]) \\\n > self.iouThreshold:\n thresholdedClassProbabilities[box2] = 0.\n # Non-suppressed boxes\n nonSuppressedIndex = np.where(thresholdedClassProbabilities > 0)\n thresholdedClassProbabilities \\\n = thresholdedClassProbabilities[nonSuppressedIndex]\n thresholdedBoxes = thresholdedBoxes[nonSuppressedIndex]\n thresholdedClasses = thresholdedClasses[nonSuppressedIndex]\n if self.debug:\n print(\"thresholdedClasses[nonSuppressedIndex].\")\n # Results\n result = []\n for i in range(len(thresholdedClasses)):\n result.append([self.classes[thresholdedClasses[i]],\n thresholdedBoxes[i][0],\n thresholdedBoxes[i][1],\n thresholdedBoxes[i][2],\n thresholdedBoxes[i][3],\n thresholdedClassProbabilities[i]])\n return result","def normalize_to_prob(inp):\n return (inp + 1)/2","def _to_prob_maps(outputs, output_type):\n\n if output_type == OutputType.LOGIT:\n prob_maps = nn.functional.softmax(outputs, dim=1)[:, 1:2]\n else:\n prob_maps = outputs\n\n return prob_maps","def u_probs(self):\n log_u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\n\n return self._prob_inverse_transform(numpy.exp(log_u))","def get_probs(self, input_pos, network):\n probs, qvalues = TFSN.get_session().run([network.probabilities, network.q_values],\n feed_dict={network.input_positions: [input_pos]})\n return probs, qvalues","def get_pred_class_probs(self, pred_mu, pred_sigma):","def predictability(self):\n temp = self.probs\n for n in range(10):\n temp = temp.dot(temp)\n final = temp[0,:]\n #Let's assume that all words have unique initial letters\n probs = map(len, self.words)\n probs = array(probs)\n probs = (probs + self.probs.max(1)-1)/probs\n return sum(final*probs)","def get_raw_probability(self):\n\t\tproba = RunOrder.BASE_SUCCESS_PROBABILITY\n\t\tproba += (self.additional_percents + self.hidden_percents) * 10\n\t\treturn proba","def probs(self) -> List:\n return self._probs","def probabilities(self):\n raise NotImplementedError","def get_probs(self, states, actions):\n # YOUR CODE HERE\n \n probs = np.ones(len(states))/2\n return probs","def log_u_probs(self):\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\n return self._prob_inverse_transform(u)","def stdProbabilityNorm(self):\n return 0.5","def predict_proba(states):\r\n # convert states, compute logits, use softmax to get probability\r\n predicted = agent(torch.Tensor(states))\r\n probs = F.softmax(predicted).data.numpy()\r\n return probs","def m_probs(self):\n log_m = self.kernel.feature_log_prob_[self._match_class_pos()]\n\n return self._prob_inverse_transform(numpy.exp(log_m))","def predict_proba(self):\n if self.rank_prob is None:\n raise ValueError('No results available. Did you already call predict(...)?')\n\n return np.array([sum(map(lambda x: x[1], result)) / len(result) for result in self.rank_prob])","def convert_output_to_class(preds,mu_stds,use_thresh=True,scale=1.0):\n preds_prob = torch.sigmoid(preds) # convert logits to probability with sigmoid\n max_class = torch.argmax(preds_prob,dim=-1).numpy().tolist() # get class with the largest probability\n max_prob = torch.max(preds_prob,dim=-1).values.detach().numpy().tolist() # get the max value of probability\n pred_class = [] # predicted class\n for i in range(len(max_prob)): # loop each output of the model\n max_class_one = max_class[i] # get class with the largest probability\n threshold = max(0.5, 1. - scale * mu_stds[max_class_one][1]) if use_thresh is True else 0.5 # find threshold for the predicted class\n # print(threshold)\n if max_prob[i] >= threshold: # if the max value of probability greater than threshold\n pred_class.append(max_class[i]) # append the max class\n else:\n pred_class.append(-1) # append unseen class\n return pred_class","def get_probs(self, a):\n with torch.no_grad():\n probabilities = (np.array(self.priorities) ** a) / sum(np.array(self.priorities) ** a)\n return probabilities","def get_probs(self):\n\t\tprobArray = []\n\t\tfor combination in self.codepool:\n\t\t\tif self.feasible(combination):\n\t\t\t\tprobArray.append(self.get_probability(combination))\n\t\t\telse:\n\t\t\t\tprobArray.append(0)\n\t\tprobArray = np.array(probArray) / np.sum(probArray)\n\t\treturn probArray","def output_probabilities(psi):\n psi_copy = deepcopy(psi)\n psi_copy.left_canonise(normalise=True)\n psi_vec = tn.onedim.contract_virtual_indices(psi_copy)\n psi_vec.fuse_indices('physout', 'physout')\n probs = abs(psi_vec.data.reshape(-1, 1)) ** 2\n return probs","def get_output_distr(self, stat_list):\n out_probs = [[np.zeros(500) for _ in stat_list]\n for _ in range(self.task_count)]\n\n # for each task, get the posterior distribution for each predicted\n # output label\n for i in range(self.task_count):\n distr_vec = [\n stats.norm(loc=mu, scale=sigma) for mu, sigma in\n zip(self.output_mat['mu'][i, :],\n self.output_mat['sigma'][i, :])\n ]\n\n # calculate the range of possible predicted output values\n min_range = min(distr.ppf(0.01) for distr in distr_vec)\n max_range = max(distr.ppf(0.99) for distr in distr_vec)\n x_vals = np.linspace(min_range, max_range, 1000)\n\n # calculate the cumulative probability density function across all\n # label distributions at each possible predicted value\n for j, stat in enumerate(stat_list):\n out_probs[i][j] = [\n (x,\n np.mean([distr.pdf(x) for distr, st in\n zip(distr_vec, stat) if st])\n ) for x in x_vals\n ]\n\n return out_probs","def pred_from_net_output(self, net_output: ALL_NET_OUTPUT) -> torch.Tensor:\n raise NotImplementedError","def get_probabilities(self):\n if not self.exposes_probabilities:\n return None\n\n return self._last_probs","def probabilities(self, x, y):\n return self.feed_and_return(x, y, self.network.a)","def get_probability_loss(self):\n return sum(self._loss)/len(self._loss)","def postprocess(self, data):\n if self.error is not None:\n return [self.error]\n\n # Iterating over inference results to render the normalized probabilities\n response = []\n for inference_result in data:\n softmax_result = inference_result.softmax().asnumpy()\n for idx, label in enumerate(self.labels):\n response.append({label: float(softmax_result[0][idx])})\n return [response]","def probs(self):\n warnings.warn(\n \"VqeResult.probs is obsoleted. \" + \"Use VqeResult.get_probs().\",\n DeprecationWarning)\n return self.get_probs()","def log_m_probs(self):\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\n return self._prob_inverse_transform(m)","def prob(self, tple, class_counts, feature_counts):\n feats = self.dataset.input_features\n unnorm = [prod(feature_counts[i][feat(tple)][c]\n for (i,feat) in enumerate(feats))\n /(class_counts[c]**(len(feats)-1))\n for c in range(self.num_classes)]\n thesum = sum(unnorm)\n return [un/thesum for un in unnorm]","def priorProbabilities():\r\n\ttotal = 0.0\r\n\tpos = 0.0\r\n\tneg = 0.0\r\n\r\n\t# Count the amount of positives and negatives in the training data\r\n\tfor item in trainingData:\r\n\t\ttotal += 1\r\n\t\tif item[1] == '0':\r\n\t\t\tpos +=1\r\n\t\tif item[1] == '1':\r\n\t\t\tneg +=1\r\n\t\t\t\r\n\t\t\t\r\n\t# Return the positive and negative probabilities \r\n\tposProb = float(pos / total * 100)\r\n\tnegProb = float(neg / total * 100)\r\n\r\n\t\r\n\t\r\n\treturn posProb, negProb","def stdProbabilityNorm(self):\n return 1./factorial(self.alpha-1)","def net_output(self):\n result = self.gives()\n for k, v in self.needs().items():\n result[k] = result.get(k, 0) - v\n\n return result","def classProbs(observation, tree, classes):\n res = classify(observation, tree) #res = results\n total = sum(res.values())\n probs = []\n for c in classes:\n if c in res.keys():\n probs.append(float(res[c])/total)\n else:\n probs.append(0)\n return probs","def normalize(init_probs):\n total_prob = sum(init_probs)\n if total_prob > 0. + InferenceUtils._eps:\n for idx in range(len(init_probs)):\n init_probs[idx] = init_probs[idx] / total_prob\n\n # TODO: check refactor > do we have to return distrib with new instance?\n return init_probs","def normalize_probability(p_unnormalized):\n p_normalized=p_unnormalized/p_unnormalized.sum(axis=0)\n return p_normalized","def predict_proba(self, X, device=None):\n preds = self._predict(X, device=device)\n probs = torch.softmax(preds, dim=1).cpu().numpy()\n return probs","def sigmoid2predictions(output: torch.Tensor) -> torch.Tensor:\n return (torch.sign(output - 0.5) + 1) / 2","def get_log_prob(self, states, actions):\n dist, _ = self.get_dist_and_mode(states)\n log_probs = dist.log_prob(actions)\n log_probs = tf.expand_dims(log_probs, -1) # To avoid broadcasting\n return log_probs","def predict_log_proba(self):\n self._check_proba()\n return self._predict_log_proba","def reconstructed_probability(self, x: torch.Tensor) -> torch.Tensor:\n with torch.no_grad():\n pred = self.predict(x)\n recon_dist = Normal(pred['recon_mu'], pred['recon_sigma'])\n x = x.unsqueeze(0)\n p = recon_dist.log_prob(x).exp().mean(dim=0).mean(dim=-1) # vector of shape [batch_size]\n return p","def prob(self):\n\t\treturn self._prob","def cumprob(self):\r\n return self.probabilities.cumsum(-1)","def _get_normalisation_stats(self):\n p_net_datasets = [self.pdf_dataset] + [self.PDE_dataset] + [self.BC_dataset]\n p_net_means, p_net_stds = get_mean_std_from_datasets(p_net_datasets)\n\n D_net_datasets = [self.PDE_dataset]\n D_net_means, D_net_stds = get_mean_std_from_datasets(D_net_datasets)\n\n U_net_datasets = [self.PDE_dataset]\n U_net_means, U_net_stds = get_mean_std_from_datasets(U_net_datasets)\n\n return p_net_means, p_net_stds, D_net_means, D_net_stds, U_net_means, U_net_stds","def sample(self, net, numSamples=None):\n\n logPsi = net(self.basis)\n\n p = self._compute_probabilities_pmapd(logPsi, self.lastNorm, self.numStatesPerDevice)\n\n nrm = mpi.global_sum(p)\n p = self._normalize_pmapd(p,nrm)\n\n self.lastNorm += 0.5 * jnp.log(nrm)\n\n return self.basis, logPsi, p","def predict_proba(self, states):\n states = Variable(torch.FloatTensor(states))\n probas = F.softmax(self.network.forward(states))\n return probas.data.numpy()","def class_probability(self, x):\n # permutation before softmax b x a x c x spatial dims --> b x c x a x spatial dims\n # as expected by PyTorch Softmax the class axis = 1 \n return self._class_prob(x.permute([0, 2, 1, 3, 4]))","def normalize(probabilities):\n for person in probabilities:\n\n # normalize the \"gene\"\n geneSum = probabilities[person][\"gene\"][0] + probabilities[person][\"gene\"][1] + probabilities[person][\"gene\"][2]\n for i in range(3):\n probabilities[person][\"gene\"][i] /= geneSum\n\n # normalize the \"trait\"\n traitSum = probabilities[person][\"trait\"][True] + probabilities[person][\"trait\"][False]\n probabilities[person][\"trait\"][True] /= traitSum\n probabilities[person][\"trait\"][False] /= traitSum","def npp_ify(values, input_mean_variance=None):\n\n distribution = distributions.normal_distribution()\n values = flex.sorted(values)\n if input_mean_variance:\n mean, variance = input_mean_variance\n else:\n mean, variance = mean_variance(values)\n\n scaled = (values - mean) / math.sqrt(variance)\n expected = distribution.quantiles(values.size())\n\n return expected, scaled","def prob(self, w):\n return self.counts[w] / self.total_count","def predict(self, output):\n # output = output.float()\n if isinstance(output, list):\n output = output[-1]\n res = t.squeeze(t.mm(output, self.multiplier), dim=1)\n\n return t.round(res)","def probability(self, X_):\n X = np.c_[np.ones(X_.shape[0]), X_] # Add one for bias to the first columns\n probs = np.zeros(X.shape[0])\n ### YOUR CODE HERE\n z = X.dot(self.w)\n probs = log_reg.logistic(z)\n ### END CODE\n assert probs.shape == (X.shape[0],)\n return probs","def edit_probs(result):\n for i in range(TOP_E):\n p = result.data[i][1]\n p = round(p, 4)\n # p_str = str(p)[1:]\n result.data[i][1] = p\n\n return result","def predict_log_proba(self, X):\n proba = self.predict_proba(X)\n\n if self.n_outputs_ == 1:\n return np.log(proba)\n\n else:\n for k in xrange(self.n_outputs_):\n proba[k] = np.log(proba[k])\n\n return proba","def unscale_outputs(outputs: np.ndarray):\n scale_factors = get_feature_scale_factors()\n return outputs * scale_factors[\"htc\"]","def _normalize(self, inp):\n \n return inp/inp.sum()","def uniform_start_probs(self) -> np.ndarray:\n return np.ones(self.n_states) / self.n_states","def probability_array(self):\n q = self.apply_weights()\n return np.exp(q)/(1 + np.exp(q))","def normalized(self):\n\n # Scale results to max at 255 for image display\n max_distance = np.max(self.depth_prediction)\n pred = 255 * self.depth_prediction // max_distance\n\n # Convert results to uint8\n pred = pred.astype(np.uint8, copy=True)\n\n # Do fancy coloring\n pred = cv2.applyColorMap(pred, cv2.COLORMAP_JET)\n\n return pred","def get_normalized_probabilities(self, begin_date):\n probs_df = self.data_provider.get_probs_df(begin_date)\n\n if probs_df.empty:\n raise OptimizationException(\"There are no investment clock predictions available\")\n sum_row = probs_df.sum(axis=1)\n norm_probs = probs_df.div(sum_row, axis=0)\n return norm_probs","def mixed_prob( means,stds,weights,validt):","def predict_log_proba(self, X):\n proba = self.predict_proba(X)\n\n if self.n_outputs_ == 1:\n return np.log(proba)\n\n else:\n for k in range(self.n_outputs_):\n proba[k] = np.log(proba[k])\n\n return proba","def predict_proba(self, inputs):\n return self.model.predict_proba(inputs)","def extract_probs(label, x):\n\tb = np.ascontiguousarray(x).view(np.dtype((np.void, x.dtype.itemsize * x.shape[1])))\n\tunique_array, unique_indices, unique_inverse_x, unique_counts = \\\n\t\tnp.unique(b, return_index=True, return_inverse=True, return_counts=True)\n\tunique_a = x[unique_indices]\n\tb1 = np.ascontiguousarray(unique_a).view(np.dtype((np.void, unique_a.dtype.itemsize * unique_a.shape[1])))\n\tpxs = unique_counts / float(np.sum(unique_counts))\n\tp_y_given_x = []\n\tfor i in range(0, len(unique_array)):\n\t\tindexs = unique_inverse_x == i\n\t\tpy_x_current = np.mean(label[indexs, :], axis=0)\n\t\tp_y_given_x.append(py_x_current)\n\tp_y_given_x = np.array(p_y_given_x).T\n\treturn p_y_given_x, b1, b, unique_a, unique_inverse_x, pxs","def lnprobability(self):\n return","def outputGenerationProbability(self):\n self.b = zeros((self.noOfEmmittingStates, self.T))\n for row in range(self.noOfEmmittingStates):\n for col in range(self.T):\n self.b[row, col] = self.gaussianDist(self.observationSequence[0, col],\n self.outputProbabilities[row, 0],\n self.outputProbabilities[row, 1])","def _get_selection_probabilities(self):\r\n probabilities = np.arange(1, self.population_size+1, dtype=float)[::-1]\r\n probabilities /= probabilities.sum()\r\n return probabilities","def uncertain_logits_to_probs(logits):\n b, n_times_d = logits.size()\n d = 3\n if n_times_d % d:\n raise ValueError('Expected logits dimension to be divisible by {}, got size {}.'.format(d, n_times_d))\n n = n_times_d // d\n\n logits = logits.view(b, n, d)\n probs = F.softmax(logits[:, :, 1:], dim=-1)\n probs = probs[:, :, 1]\n\n return probs","def postprocess(output):\n text=''\n order = output.argsort()[::-1][:6]\n # print('\\n------- predictions --------')\n for i in range(1):\n # print ('prediction ' + str(i) + ' (probability ' + str(output[order[i]]*100) + '%) is ' + gNetworkCategories[order[i]] + ' label index is: ' + str(order[i]) )\n text=text+str(gNetworkCategories[order[i]])\n\n return text","def stdProbabilityNorm(self):\n B = factorial(self.alpha-1)*factorial(self.beta-1)/factorial(self.alpha+self.beta-1)\n norm = 1.0/(2**(self.alpha+self.beta-1)*B)\n return norm","def value_predictions(self):\n return np.array([m['critic'] for m in self.model_outs], dtype=np.float32)","def log_prob(self):\n if not RerankingParser._parser_model_loaded:\n raise ValueError(\"You need to have loaded a parser model in \"\n \"order to get the log probability.\")\n return parser.treeLogProb(self._tree)","def logit_to_prob(logits: Tensor, criterion):\n logits = logits.detach()\n\n if logits.size(1) == 2:\n # return logits.softmax()[:, 0:1, ...] # Take probabilities of the first class (salt)\n return logits.argmax(dim=1).float()\n elif logits.size(1) == 1:\n if isinstance(criterion, LovaszHingeLoss) or criterion == 'lovasz':\n return (logits > 0).float()\n else:\n return logits.sigmoid()\n\n raise ValueError('Unsupported number of channels')","def model_probs(self, classifier=None):\n if not classifier:\n classifier = RandomForestClassifier(n_estimators=100, n_jobs=-1)\n classifier.fit(self.X_train, self.y_train)\n predictions = classifier.predict_proba(self.X)\n return predictions","def measure_rate(net, n_samples=10):\n from scipy.stats import multivariate_normal as mn\n\n dataset_dir, dataset_pth = make_dataset_pths(net)\n print(\"dataset path: \", dataset_pth)\n X, Probes, Change_prob, Perceptual_dist = load_or_make_dataset(\n net, dataset_pth, dataset_dir, net.dataset_size)\n Rx = []\n mu, logsigma = [], []\n i = 0\n while True:\n if i * net.batch_size > len(X) - 1:\n break\n x = X[i * net.batch_size:(i + 1) * net.batch_size]\n m, ls = net.encode_presample(x, keep_session=True)\n mu.append(m)\n logsigma.append(ls)\n i += 1\n mu = np.vstack(mu)\n logsigma = np.vstack(logsigma)\n print(\"Dataset encoded.\")\n z = [\n mn.rvs(mean=mu[j], cov=np.diag(np.exp(logsigma[j])), size=n_samples)\n for j in range(len(mu))\n ]\n p_z_given_x = [\n mn.logpdf(z[j], mean=mu[j], cov=np.diag(np.exp(logsigma[j])))\n for j in range(len(mu))\n ]\n m_z = [\n mn.logpdf(\n z[j], mean=np.zeros(net.latent_size), cov=np.eye(net.latent_size))\n for j in range(len(mu))\n ]\n Rx = [(p_z_given_x[j] - m_z[j]).sum() / n_samples for j in range(len(mu))]\n R = sum(Rx) / len(X)\n print(R)\n return R","def predict_prob(self, _input_data):\n yhat_probs = (self.merged_model).predict(_input_data, verbose=0)\n\n return yhat_probs[:, 0]","def pnet_process_per_scale(self, pnet_output, scale):\n conf = pnet_output['prob1'][0, 1, :, :]\n (y, x) = np.where(conf >= self.threshold[0])\n if len(x) == 0:\n return None\n stride = 2\n cell_size = 12\n bounding_box = np.array([y, x])\n bb1 = np.around(stride * bounding_box / scale)\n bb2 = np.around((stride * bounding_box + cell_size - 1) / scale)\n score = np.array([conf[y, x]])\n coord = pnet_output['conv4-2'][0]\n regression = np.array([coord[1, y, x], coord[0, y, x], \\\n coord[3, y, x], coord[2, y, x]])\n boxes = np.concatenate((bb1, bb2, score, regression), axis=0).T\n boxes = self.__nms(boxes, 0.5, 'Union')\n return boxes","def predict_proba(self, x):\n e = self.predict_evidence(x)\n a = e + self.prior\n return a / torch.sum(a, dim=-1, keepdim=True)","def predict_proba(self, samples):\n predictions, class_ids = self.__predict(samples)\n\n # analyze\n probabilities = []\n\n for class_id, p in predictions.iteritems():\n probabilities.append(len(p[p > 0]) / float(len(samples)))\n class_ids.append(class_id)\n return np.array(probabilities), np.array(class_ids)","def clean_outputs(outputs):\n return [1 if sigmoid(b) > 0.5 else 0 for b in outputs]","def p_to_prediction(self, p):\n if isinstance(p, list):\n return [self.p_to_prediction(_p) for _p in p]\n elif isinstance(p, Normal):\n pred = p.loc.cpu().detach().numpy()\n elif isinstance(p, Bernoulli):\n pred = p.probs.cpu().detach().numpy()\n else:\n raise NotImplementedError\n return pred","def probability(self, X_):\n X = np.c_[np.ones(X_.shape[0]), X_] # add bias variable 1\n prob = np.zeros(X.shape[0], self.num_classes)\n ### YOUR CODE HERE\n z = X.dot(self.w)\n prob = soft_reg.softmax(z)\n ### END CODE\n return prob","def precision(classifier_output, true_labels):\n\n # TODO: finish this.\n conf_matrix = confusion_matrix(classifier_output, true_labels)\n return conf_matrix[0][0]/(conf_matrix[0][0] + conf_matrix[1][0])","def update_probs(self, measure, p, enemy_net = False):\n tmp_net = []\n net_size = len(self.net) \n if not enemy_net:\n net = self.net\n else:\n net = self.enemy_net\n #Maps a given color to its corresponding column in the color's \n #probability table.\n if measure == GREEN:\n color = 0\n elif measure == YELLOW:\n color = 1\n elif measure == ORANGE:\n color = 2\n elif measure == RED:\n color = 3\n #Obtains new probabilities by using the distance between the\n #observed position (the one measured) and any other position.\n for j in range(0, net_size):\n distance = self.__get_distance(p, j)\n if distance == 0: #When updating the measured position's probability.\n tmp_net.append(net[j].value * self.ct[0][color])\n elif distance == 1: #When updating an adjacent position to the one measured.\n tmp_net.append(net[j].value * self.ct[1][color])\n elif distance == 2: #When updating a position at two cells from the one measured.\n tmp_net.append(net[j].value * self.ct[2][color])\n elif distance == 3: #When updating a position at three cells from the one measured.\n tmp_net.append(net[j].value * self.ct[3][color])\n else: #When updating a position at four or more cells from the one measured.\n tmp_net.append(net[j].value * self.ct[4][color])\n #Obtains summation of new probabilities in order to execute \n #a posterior normalization.\n total = sum(tmp_net)\n #Normalizes new probabilities and assigns them to its \n #corresponding position.\n for i in range(0, net_size):\n net[i].value = tmp_net[i]/total","def _compute_outputs(self, *args, **kwargs):\n pass\n # self.outputs = self.model(input_ids=self.input_ids, masked_lm_labels=self.input_ids)\n # self.logits = self.outputs[0][0]\n # self.probs = torch.softmax(self.logits, 1)","def unnormalizeFromParams(output, norm_params):\n # for mean in norm_params[0:3]: #take the first three because that's the mean\n output[0] = (float(output[0]) * float(norm_params[3])) + float(norm_params[0])\n output[1] = (float(output[1]) * float(norm_params[4])) + float(norm_params[1])\n output[2] = (float(output[2]) * float(norm_params[5])) + float(norm_params[2])\n\n return output","def sentence_logprob(self, sentence):\n line = get_ngrams(sentence,3)\n log_por = 0.0\n for item in line:\n raw_por = self.smoothed_trigram_probability(item)\n log_por = log_por+math.log2(raw_por)\n\n return float(log_por)","def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\n\n self._check_input_data(X=X)\n self._check_support(X=X, n=self.n)\n\n if not isinstance(self.prob, np.ndarray):\n log_proba = stats.binom.logpmf(X, n=self.n, p=self.prob)\n else:\n n_samples = X.shape[0]\n n_classes = len(self.prob) # type: ignore\n log_proba = np.zeros((n_samples, n_classes))\n\n for cls in range(n_classes):\n log_proba[:, cls] = stats.binom.logpmf(X, n=self.n, p=self.prob[cls]) # type: ignore\n\n return log_proba","def predict_proba(self, X, check_input=True):\n check_is_fitted(self, 'tree_')\n X = self._validate_X_predict(X, check_input)\n proba = self.tree_.predict(X)\n\n if self.n_outputs_ == 1:\n proba = proba[:, :self.n_classes_]\n normalizer = proba.sum(axis=1)[:, np.newaxis]\n normalizer[normalizer == 0.0] = 1.0\n proba /= normalizer\n\n return proba\n\n else:\n all_proba = []\n\n for k in range(self.n_outputs_):\n proba_k = proba[:, k, :self.n_classes_[k]]\n normalizer = proba_k.sum(axis=1)[:, np.newaxis]\n normalizer[normalizer == 0.0] = 1.0\n proba_k /= normalizer\n all_proba.append(proba_k)\n\n return all_proba","def probOut(self) -> dict:\n \n return {\n j: sum(\n [ self.mat[i][j] * self.probIn[i] for i in self.simbIn ]\n ) for j in self.simbOut\n }","def get_nml_probs(x, model, data=None, normalize=True, num_classes=2, query_point_weight=20, dist_weight_thresh=None, \n num_grad_steps=10, lr=0.01, batch_size=32, grad_penalty=None, verbose=False, \n show_plots=False, plotting_2d=False, return_params=False):\n results = []\n data = data or DEFAULT_DATA\n orig_inputs, orig_targets = data\n \n if show_plots and plotting_2d:\n plt.figure()\n plt.title(f\"Original rewards\")\n plot_rewards(model, contours=True)\n plot_dataset(data)\n \n marker_for_class = {\n 0: 'x',\n 1: '*'\n }\n \n model.cuda()\n num_batches = ceil(len(orig_inputs) / batch_size)\n\n # NOTE train on gpu, move back to cpu for eval\n \n for proposed_class in range(num_classes):\n new_model = copy.deepcopy(model)\n new_model.cuda()\n \n # Sample all of the adaptation batches in advance\n optimizer = optim.SGD(new_model.parameters(), lr=lr)\n \n for _ in range(num_grad_steps):\n idxs = np.random.permutation(range(len(orig_inputs)))[:batch_size-1]\n X, y = orig_inputs[idxs], orig_targets[idxs]\n X = torch.Tensor(np.vstack((X, x))).cuda()\n y = torch.Tensor(np.hstack((y, proposed_class))).long().cuda()\n \n logits = new_model(X)\n loss = F.cross_entropy(logits, y, reduction='none')\n \n if dist_weight_thresh:\n weights = np.exp(-np.linalg.norm(x - X.cpu().numpy(), axis=-1) * 2.3 / dist_weight_thresh)\n else:\n weights = np.ones(len(y))\n \n weights[-1] *= query_point_weight * 1. / num_batches\n weights = torch.Tensor(weights).cuda()\n loss = torch.sum(loss * weights) / torch.sum(weights)\n \n loss.backward()\n optimizer.step()\n \n new_model.cpu()\n \n with torch.no_grad():\n x_tensor = torch.Tensor(x[None])\n probs = torch.softmax(new_model(x_tensor), -1)\n results.append(probs[0][proposed_class].item())\n \n if show_plots:\n new_model.to(torch.device(\"cpu\"))\n\n if plotting_2d: \n plt.figure()\n plot_rewards(new_model, contours=True, env = False, title=f\"Finetuning on label {proposed_class}\")\n plot_dataset(data)\n plt.scatter(x[0], x[1], marker=marker_for_class[proposed_class], color='w', s=100)\n \n plt.figure()\n plt.title(f\"Losses for label {proposed_class}\")\n plt.plot(losses)\n \n plt.figure()\n plt.title(f\"x loss for label {proposed_class}\")\n plt.plot(x_losses)\n \n plt.figure()\n plt.title(f\"x probs for label {proposed_class}\")\n plt.plot(x_vals)\n \n model.cpu()\n \n if normalize:\n results = np.array(results) / sum(results)\n else:\n results = np.array(results)\n return results if not return_params else (results, new_model)"],"string":"[\n \"def get_normalized_probs(self, net_output, log_probs, sample=None):\\n encoder_out = net_output[\\\"encoder_out\\\"]\\n if torch.is_tensor(encoder_out):\\n logits = encoder_out.float()\\n if log_probs:\\n return F.log_softmax(logits, dim=-1)\\n else:\\n return F.softmax(logits, dim=-1)\\n raise NotImplementedError\",\n \"def get_normalized_probs(self, net_output, log_probs):\\n logits = net_output\\n if log_probs:\\n return F.log_softmax(logits, dim=1)\\n else:\\n return F.softmax(logits, dim=1)\",\n \"def get_normalized_probs(\\n self,\\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\\n log_probs: bool,\\n sample: Optional[Dict[str, Tensor]],\\n ):\\n\\n if hasattr(self, \\\"adaptive_softmax\\\") and self.adaptive_softmax is not None:\\n if sample is not None:\\n assert \\\"target\\\" in sample\\n target = sample[\\\"target\\\"]\\n else:\\n target = None\\n out = self.adaptive_softmax.get_log_prob(net_output[0], target=target)\\n return out.exp_() if not log_probs else out\\n\\n logits = net_output[0]\\n if log_probs:\\n return utils.log_softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\\n else:\\n return utils.softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\",\n \"def get_normalized_probs(\\n self,\\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\\n log_probs: bool,\\n sample: Optional[Dict[str, Tensor]] = None,\\n ):\\n\\n if hasattr(self, \\\"adaptive_softmax\\\") and self.adaptive_softmax is not None:\\n if sample is not None:\\n assert \\\"target\\\" in sample\\n target = sample[\\\"target\\\"]\\n else:\\n target = None\\n out = self.adaptive_softmax.get_log_prob(net_output[0], target=target)\\n return out.exp_() if not log_probs else out\\n\\n logits = net_output[0]\\n if log_probs:\\n return log_softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\\n else:\\n return softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\",\n \"def get_normalized_probs_scriptable(\\n self,\\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\\n log_probs: bool,\\n sample: Optional[Dict[str, Tensor]] = None,\\n ):\\n if hasattr(self, \\\"decoder\\\"):\\n return self.decoder.get_normalized_probs(net_output, log_probs, sample)\\n elif torch.is_tensor(net_output):\\n # syntactic sugar for simple models which don't have a decoder\\n # (e.g., the classification tutorial)\\n logits = net_output.float()\\n if log_probs:\\n return F.log_softmax(logits, dim=-1)\\n else:\\n return F.softmax(logits, dim=-1)\\n raise NotImplementedError\",\n \"def __get_net_probs(self):\\n return np.array([node.value for node in self.net]).reshape(5,5)\",\n \"def log_probs(self):\\n return np.array([m['log_probs'] for m in self.model_outs], dtype=np.float32)\",\n \"def transform_output_probs(self, y, get_prob = False):\\n return np.array(self.sample_labels(y,\\n num_of_sents = len(y), # all sentences\\n num_of_samples = max(map(len, y)), # all words\\n num_of_classes = 1, # Only top probability\\n start_index = 0, # all sentences\\n get_prob = get_prob, # Indicate whether to get only labels\\n ))\",\n \"def transform_output_probs(self, y, get_prob = False):\\n return np.array(self.sample_labels(y,\\n num_of_sents = len(y), # all sentences\\n num_of_samples = max(map(len, y)), # all words\\n num_of_classes = 1, # Only top probability\\n start_index = 0, # all sentences\\n get_prob = get_prob, # Indicate whether to get only labels\\n ))\",\n \"def interpret_output(self, netOutput):\\n # Class Conditional Probability: P(class | object),\\n # i.e. assuming there is an object in the grid being considered,\\n # what is the probability the object belongs to each class\\n self.classConditionalProbability = np.reshape(\\n netOutput[:, :self.endIndexOfClassConditionalProbability],\\n [self.numOfGridsIn1D, self.numOfGridsIn1D, self.numOfClasses]\\n )\\n if self.debug:\\n print(\\\"classConditionalProbability.\\\")\\n # P(object): Object probability, i.e. the probability of an\\n # object in each bounding box in each grid\\n self.objectProbability = np.reshape(\\n netOutput[\\n :,\\n self.endIndexOfClassConditionalProbability:\\\\\\n self.endIndexOfObjectProbability\\n ],\\n [self.numOfGridsIn1D, self.numOfGridsIn1D, self.numOfBoxesPerGrid]\\n )\\n if self.debug:\\n print(\\\"objectProbability.\\\")\\n # objectClassProbability: P(class | object) * P(object), i.e.\\n # the probability of an object present, and it being each class\\n # Equivalent to:\\n #for i in range(self.numOfBoxesPerGrid):\\n # for j in range(self.numOfClasses):\\n # self.objectClassProbability[:, :, i, j] = np.multiply(\\n # self.objectProbability[:, :, i],\\n # self.classConditionalProbability[:, :, j]\\n # )\\n # Also equivalent to:\\n # for i in range(self.numOfGridsIn1D):\\n # for j in range(self.numOfGridsIn1D):\\n # self.objectClassProbability[i, j] = np.outer(\\n # self.objectProbability[i, j, :],\\n # self.classConditionalProbability[i, j, :]\\n # )\\n # Or:\\n self.objectClassProbability = np.einsum(\\n '...i, ...j',\\n self.objectProbability,\\n self.classConditionalProbability,\\n out=self.objectClassProbability\\n )\\n if self.debug:\\n print(\\\"objectClassProbability.\\\")\\n # (x, y, w, h) == (<left> <top> <right> <bottom>) of the\\n # numOfBoxesPerGrid bounding boxes predicted by the network\\n self.boxData = np.reshape(\\n netOutput[:, self.endIndexOfObjectProbability:],\\n [self.numOfGridsIn1D, self.numOfGridsIn1D, self.numOfBoxesPerGrid, 4]\\n )\\n # Changing x <left> and y <top> coordinates from within-grid\\n # coordinates to image coordinates\\n self.boxData[:, :, :, 0] = 1. * \\\\\\n (self.boxData[:, :, :, 0]+self.offsetX) * self.imageWidth \\\\\\n / self.numOfGridsIn1D\\n self.boxData[:, :, :, 1] = 1. * \\\\\\n (self.boxData[:, :, :, 1]+self.offsetY) * self.imageHeight \\\\\\n / self.numOfGridsIn1D\\n # Changing width and height from model representation to image\\n # representation, square root of the width and height is predicted\\n # because small error in small boxes matter much more than small errors\\n # in large boxes\\n self.boxData[:, :, :, 2] = self.imageWidth * np.multiply(\\n self.boxData[:, :, :, 2],\\n self.boxData[:, :, :, 2]\\n )\\n self.boxData[:, :, :, 3] = self.imageHeight * np.multiply(\\n self.boxData[:, :, :, 3],\\n self.boxData[:, :, :, 3]\\n )\\n if self.debug:\\n print(\\\"boxData.\\\")\\n # Find out the index of the class with maximum probability for\\n # every object/bounding box\\n self.maxProbableClasses = np.argmax(self.objectClassProbability, axis=3)\\n if self.debug:\\n print(\\\"maxProbableClasses.\\\")\\n # Find out the probability value of these max classes\\n self.maxProbableClassProbabilities = np.max(\\n self.objectClassProbability, axis=3\\n )\\n if self.debug:\\n print(\\\"maxProbableClassProbabilities.\\\")\\n # Eliminate those objects whose class probabilities are lesser\\n # than minClassProbability\\n thresholdedClassesIndex = np.where(\\n self.maxProbableClassProbabilities >= self.minClassProbability\\n )\\n if self.debug:\\n print(\\\"thresholdedClassesIndex.\\\")\\n # The classes\\n thresholdedClasses = self.maxProbableClasses[thresholdedClassesIndex]\\n if self.debug:\\n print(\\\"thresholdedClasses.\\\")\\n # The class probabilities\\n thresholdedClassProbabilities = self.maxProbableClassProbabilities[\\n thresholdedClassesIndex\\n ]\\n if self.debug:\\n print(\\\"thresholdedClassProbabilities.\\\")\\n # Find out the boxes corresponding to the filtered objects\\n thresholdedBoxes = self.boxData[\\n thresholdedClassesIndex[0],\\n thresholdedClassesIndex[1],\\n thresholdedClassesIndex[2]\\n ]\\n if self.debug:\\n print(\\\"thresholdedBoxes.\\\")\\n # Sort the boxes and classes based on probabilities\\n sortOrder = np.argsort(thresholdedClassProbabilities)[::-1]\\n if self.debug:\\n print(\\\"sortOrder.\\\")\\n thresholdedClassProbabilities \\\\\\n = thresholdedClassProbabilities[sortOrder]\\n thresholdedBoxes = thresholdedBoxes[sortOrder]\\n thresholdedClasses = thresholdedClasses[sortOrder]\\n if self.debug:\\n print(\\\"thresholdedClasses.\\\")\\n # Non-maximum supression\\n for box1 in range(len(thresholdedClassProbabilities)):\\n if thresholdedClassProbabilities[box1] == 0.:\\n continue\\n for box2 in range(box1 + 1, len(thresholdedClassProbabilities)):\\n if self.iou(thresholdedBoxes[box1], thresholdedBoxes[box2]) \\\\\\n > self.iouThreshold:\\n thresholdedClassProbabilities[box2] = 0.\\n # Non-suppressed boxes\\n nonSuppressedIndex = np.where(thresholdedClassProbabilities > 0)\\n thresholdedClassProbabilities \\\\\\n = thresholdedClassProbabilities[nonSuppressedIndex]\\n thresholdedBoxes = thresholdedBoxes[nonSuppressedIndex]\\n thresholdedClasses = thresholdedClasses[nonSuppressedIndex]\\n if self.debug:\\n print(\\\"thresholdedClasses[nonSuppressedIndex].\\\")\\n # Results\\n result = []\\n for i in range(len(thresholdedClasses)):\\n result.append([self.classes[thresholdedClasses[i]],\\n thresholdedBoxes[i][0],\\n thresholdedBoxes[i][1],\\n thresholdedBoxes[i][2],\\n thresholdedBoxes[i][3],\\n thresholdedClassProbabilities[i]])\\n return result\",\n \"def normalize_to_prob(inp):\\n return (inp + 1)/2\",\n \"def _to_prob_maps(outputs, output_type):\\n\\n if output_type == OutputType.LOGIT:\\n prob_maps = nn.functional.softmax(outputs, dim=1)[:, 1:2]\\n else:\\n prob_maps = outputs\\n\\n return prob_maps\",\n \"def u_probs(self):\\n log_u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\\n\\n return self._prob_inverse_transform(numpy.exp(log_u))\",\n \"def get_probs(self, input_pos, network):\\n probs, qvalues = TFSN.get_session().run([network.probabilities, network.q_values],\\n feed_dict={network.input_positions: [input_pos]})\\n return probs, qvalues\",\n \"def get_pred_class_probs(self, pred_mu, pred_sigma):\",\n \"def predictability(self):\\n temp = self.probs\\n for n in range(10):\\n temp = temp.dot(temp)\\n final = temp[0,:]\\n #Let's assume that all words have unique initial letters\\n probs = map(len, self.words)\\n probs = array(probs)\\n probs = (probs + self.probs.max(1)-1)/probs\\n return sum(final*probs)\",\n \"def get_raw_probability(self):\\n\\t\\tproba = RunOrder.BASE_SUCCESS_PROBABILITY\\n\\t\\tproba += (self.additional_percents + self.hidden_percents) * 10\\n\\t\\treturn proba\",\n \"def probs(self) -> List:\\n return self._probs\",\n \"def probabilities(self):\\n raise NotImplementedError\",\n \"def get_probs(self, states, actions):\\n # YOUR CODE HERE\\n \\n probs = np.ones(len(states))/2\\n return probs\",\n \"def log_u_probs(self):\\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\\n return self._prob_inverse_transform(u)\",\n \"def stdProbabilityNorm(self):\\n return 0.5\",\n \"def predict_proba(states):\\r\\n # convert states, compute logits, use softmax to get probability\\r\\n predicted = agent(torch.Tensor(states))\\r\\n probs = F.softmax(predicted).data.numpy()\\r\\n return probs\",\n \"def m_probs(self):\\n log_m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n\\n return self._prob_inverse_transform(numpy.exp(log_m))\",\n \"def predict_proba(self):\\n if self.rank_prob is None:\\n raise ValueError('No results available. Did you already call predict(...)?')\\n\\n return np.array([sum(map(lambda x: x[1], result)) / len(result) for result in self.rank_prob])\",\n \"def convert_output_to_class(preds,mu_stds,use_thresh=True,scale=1.0):\\n preds_prob = torch.sigmoid(preds) # convert logits to probability with sigmoid\\n max_class = torch.argmax(preds_prob,dim=-1).numpy().tolist() # get class with the largest probability\\n max_prob = torch.max(preds_prob,dim=-1).values.detach().numpy().tolist() # get the max value of probability\\n pred_class = [] # predicted class\\n for i in range(len(max_prob)): # loop each output of the model\\n max_class_one = max_class[i] # get class with the largest probability\\n threshold = max(0.5, 1. - scale * mu_stds[max_class_one][1]) if use_thresh is True else 0.5 # find threshold for the predicted class\\n # print(threshold)\\n if max_prob[i] >= threshold: # if the max value of probability greater than threshold\\n pred_class.append(max_class[i]) # append the max class\\n else:\\n pred_class.append(-1) # append unseen class\\n return pred_class\",\n \"def get_probs(self, a):\\n with torch.no_grad():\\n probabilities = (np.array(self.priorities) ** a) / sum(np.array(self.priorities) ** a)\\n return probabilities\",\n \"def get_probs(self):\\n\\t\\tprobArray = []\\n\\t\\tfor combination in self.codepool:\\n\\t\\t\\tif self.feasible(combination):\\n\\t\\t\\t\\tprobArray.append(self.get_probability(combination))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprobArray.append(0)\\n\\t\\tprobArray = np.array(probArray) / np.sum(probArray)\\n\\t\\treturn probArray\",\n \"def output_probabilities(psi):\\n psi_copy = deepcopy(psi)\\n psi_copy.left_canonise(normalise=True)\\n psi_vec = tn.onedim.contract_virtual_indices(psi_copy)\\n psi_vec.fuse_indices('physout', 'physout')\\n probs = abs(psi_vec.data.reshape(-1, 1)) ** 2\\n return probs\",\n \"def get_output_distr(self, stat_list):\\n out_probs = [[np.zeros(500) for _ in stat_list]\\n for _ in range(self.task_count)]\\n\\n # for each task, get the posterior distribution for each predicted\\n # output label\\n for i in range(self.task_count):\\n distr_vec = [\\n stats.norm(loc=mu, scale=sigma) for mu, sigma in\\n zip(self.output_mat['mu'][i, :],\\n self.output_mat['sigma'][i, :])\\n ]\\n\\n # calculate the range of possible predicted output values\\n min_range = min(distr.ppf(0.01) for distr in distr_vec)\\n max_range = max(distr.ppf(0.99) for distr in distr_vec)\\n x_vals = np.linspace(min_range, max_range, 1000)\\n\\n # calculate the cumulative probability density function across all\\n # label distributions at each possible predicted value\\n for j, stat in enumerate(stat_list):\\n out_probs[i][j] = [\\n (x,\\n np.mean([distr.pdf(x) for distr, st in\\n zip(distr_vec, stat) if st])\\n ) for x in x_vals\\n ]\\n\\n return out_probs\",\n \"def pred_from_net_output(self, net_output: ALL_NET_OUTPUT) -> torch.Tensor:\\n raise NotImplementedError\",\n \"def get_probabilities(self):\\n if not self.exposes_probabilities:\\n return None\\n\\n return self._last_probs\",\n \"def probabilities(self, x, y):\\n return self.feed_and_return(x, y, self.network.a)\",\n \"def get_probability_loss(self):\\n return sum(self._loss)/len(self._loss)\",\n \"def postprocess(self, data):\\n if self.error is not None:\\n return [self.error]\\n\\n # Iterating over inference results to render the normalized probabilities\\n response = []\\n for inference_result in data:\\n softmax_result = inference_result.softmax().asnumpy()\\n for idx, label in enumerate(self.labels):\\n response.append({label: float(softmax_result[0][idx])})\\n return [response]\",\n \"def probs(self):\\n warnings.warn(\\n \\\"VqeResult.probs is obsoleted. \\\" + \\\"Use VqeResult.get_probs().\\\",\\n DeprecationWarning)\\n return self.get_probs()\",\n \"def log_m_probs(self):\\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n return self._prob_inverse_transform(m)\",\n \"def prob(self, tple, class_counts, feature_counts):\\n feats = self.dataset.input_features\\n unnorm = [prod(feature_counts[i][feat(tple)][c]\\n for (i,feat) in enumerate(feats))\\n /(class_counts[c]**(len(feats)-1))\\n for c in range(self.num_classes)]\\n thesum = sum(unnorm)\\n return [un/thesum for un in unnorm]\",\n \"def priorProbabilities():\\r\\n\\ttotal = 0.0\\r\\n\\tpos = 0.0\\r\\n\\tneg = 0.0\\r\\n\\r\\n\\t# Count the amount of positives and negatives in the training data\\r\\n\\tfor item in trainingData:\\r\\n\\t\\ttotal += 1\\r\\n\\t\\tif item[1] == '0':\\r\\n\\t\\t\\tpos +=1\\r\\n\\t\\tif item[1] == '1':\\r\\n\\t\\t\\tneg +=1\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\r\\n\\t# Return the positive and negative probabilities \\r\\n\\tposProb = float(pos / total * 100)\\r\\n\\tnegProb = float(neg / total * 100)\\r\\n\\r\\n\\t\\r\\n\\t\\r\\n\\treturn posProb, negProb\",\n \"def stdProbabilityNorm(self):\\n return 1./factorial(self.alpha-1)\",\n \"def net_output(self):\\n result = self.gives()\\n for k, v in self.needs().items():\\n result[k] = result.get(k, 0) - v\\n\\n return result\",\n \"def classProbs(observation, tree, classes):\\n res = classify(observation, tree) #res = results\\n total = sum(res.values())\\n probs = []\\n for c in classes:\\n if c in res.keys():\\n probs.append(float(res[c])/total)\\n else:\\n probs.append(0)\\n return probs\",\n \"def normalize(init_probs):\\n total_prob = sum(init_probs)\\n if total_prob > 0. + InferenceUtils._eps:\\n for idx in range(len(init_probs)):\\n init_probs[idx] = init_probs[idx] / total_prob\\n\\n # TODO: check refactor > do we have to return distrib with new instance?\\n return init_probs\",\n \"def normalize_probability(p_unnormalized):\\n p_normalized=p_unnormalized/p_unnormalized.sum(axis=0)\\n return p_normalized\",\n \"def predict_proba(self, X, device=None):\\n preds = self._predict(X, device=device)\\n probs = torch.softmax(preds, dim=1).cpu().numpy()\\n return probs\",\n \"def sigmoid2predictions(output: torch.Tensor) -> torch.Tensor:\\n return (torch.sign(output - 0.5) + 1) / 2\",\n \"def get_log_prob(self, states, actions):\\n dist, _ = self.get_dist_and_mode(states)\\n log_probs = dist.log_prob(actions)\\n log_probs = tf.expand_dims(log_probs, -1) # To avoid broadcasting\\n return log_probs\",\n \"def predict_log_proba(self):\\n self._check_proba()\\n return self._predict_log_proba\",\n \"def reconstructed_probability(self, x: torch.Tensor) -> torch.Tensor:\\n with torch.no_grad():\\n pred = self.predict(x)\\n recon_dist = Normal(pred['recon_mu'], pred['recon_sigma'])\\n x = x.unsqueeze(0)\\n p = recon_dist.log_prob(x).exp().mean(dim=0).mean(dim=-1) # vector of shape [batch_size]\\n return p\",\n \"def prob(self):\\n\\t\\treturn self._prob\",\n \"def cumprob(self):\\r\\n return self.probabilities.cumsum(-1)\",\n \"def _get_normalisation_stats(self):\\n p_net_datasets = [self.pdf_dataset] + [self.PDE_dataset] + [self.BC_dataset]\\n p_net_means, p_net_stds = get_mean_std_from_datasets(p_net_datasets)\\n\\n D_net_datasets = [self.PDE_dataset]\\n D_net_means, D_net_stds = get_mean_std_from_datasets(D_net_datasets)\\n\\n U_net_datasets = [self.PDE_dataset]\\n U_net_means, U_net_stds = get_mean_std_from_datasets(U_net_datasets)\\n\\n return p_net_means, p_net_stds, D_net_means, D_net_stds, U_net_means, U_net_stds\",\n \"def sample(self, net, numSamples=None):\\n\\n logPsi = net(self.basis)\\n\\n p = self._compute_probabilities_pmapd(logPsi, self.lastNorm, self.numStatesPerDevice)\\n\\n nrm = mpi.global_sum(p)\\n p = self._normalize_pmapd(p,nrm)\\n\\n self.lastNorm += 0.5 * jnp.log(nrm)\\n\\n return self.basis, logPsi, p\",\n \"def predict_proba(self, states):\\n states = Variable(torch.FloatTensor(states))\\n probas = F.softmax(self.network.forward(states))\\n return probas.data.numpy()\",\n \"def class_probability(self, x):\\n # permutation before softmax b x a x c x spatial dims --> b x c x a x spatial dims\\n # as expected by PyTorch Softmax the class axis = 1 \\n return self._class_prob(x.permute([0, 2, 1, 3, 4]))\",\n \"def normalize(probabilities):\\n for person in probabilities:\\n\\n # normalize the \\\"gene\\\"\\n geneSum = probabilities[person][\\\"gene\\\"][0] + probabilities[person][\\\"gene\\\"][1] + probabilities[person][\\\"gene\\\"][2]\\n for i in range(3):\\n probabilities[person][\\\"gene\\\"][i] /= geneSum\\n\\n # normalize the \\\"trait\\\"\\n traitSum = probabilities[person][\\\"trait\\\"][True] + probabilities[person][\\\"trait\\\"][False]\\n probabilities[person][\\\"trait\\\"][True] /= traitSum\\n probabilities[person][\\\"trait\\\"][False] /= traitSum\",\n \"def npp_ify(values, input_mean_variance=None):\\n\\n distribution = distributions.normal_distribution()\\n values = flex.sorted(values)\\n if input_mean_variance:\\n mean, variance = input_mean_variance\\n else:\\n mean, variance = mean_variance(values)\\n\\n scaled = (values - mean) / math.sqrt(variance)\\n expected = distribution.quantiles(values.size())\\n\\n return expected, scaled\",\n \"def prob(self, w):\\n return self.counts[w] / self.total_count\",\n \"def predict(self, output):\\n # output = output.float()\\n if isinstance(output, list):\\n output = output[-1]\\n res = t.squeeze(t.mm(output, self.multiplier), dim=1)\\n\\n return t.round(res)\",\n \"def probability(self, X_):\\n X = np.c_[np.ones(X_.shape[0]), X_] # Add one for bias to the first columns\\n probs = np.zeros(X.shape[0])\\n ### YOUR CODE HERE\\n z = X.dot(self.w)\\n probs = log_reg.logistic(z)\\n ### END CODE\\n assert probs.shape == (X.shape[0],)\\n return probs\",\n \"def edit_probs(result):\\n for i in range(TOP_E):\\n p = result.data[i][1]\\n p = round(p, 4)\\n # p_str = str(p)[1:]\\n result.data[i][1] = p\\n\\n return result\",\n \"def predict_log_proba(self, X):\\n proba = self.predict_proba(X)\\n\\n if self.n_outputs_ == 1:\\n return np.log(proba)\\n\\n else:\\n for k in xrange(self.n_outputs_):\\n proba[k] = np.log(proba[k])\\n\\n return proba\",\n \"def unscale_outputs(outputs: np.ndarray):\\n scale_factors = get_feature_scale_factors()\\n return outputs * scale_factors[\\\"htc\\\"]\",\n \"def _normalize(self, inp):\\n \\n return inp/inp.sum()\",\n \"def uniform_start_probs(self) -> np.ndarray:\\n return np.ones(self.n_states) / self.n_states\",\n \"def probability_array(self):\\n q = self.apply_weights()\\n return np.exp(q)/(1 + np.exp(q))\",\n \"def normalized(self):\\n\\n # Scale results to max at 255 for image display\\n max_distance = np.max(self.depth_prediction)\\n pred = 255 * self.depth_prediction // max_distance\\n\\n # Convert results to uint8\\n pred = pred.astype(np.uint8, copy=True)\\n\\n # Do fancy coloring\\n pred = cv2.applyColorMap(pred, cv2.COLORMAP_JET)\\n\\n return pred\",\n \"def get_normalized_probabilities(self, begin_date):\\n probs_df = self.data_provider.get_probs_df(begin_date)\\n\\n if probs_df.empty:\\n raise OptimizationException(\\\"There are no investment clock predictions available\\\")\\n sum_row = probs_df.sum(axis=1)\\n norm_probs = probs_df.div(sum_row, axis=0)\\n return norm_probs\",\n \"def mixed_prob( means,stds,weights,validt):\",\n \"def predict_log_proba(self, X):\\n proba = self.predict_proba(X)\\n\\n if self.n_outputs_ == 1:\\n return np.log(proba)\\n\\n else:\\n for k in range(self.n_outputs_):\\n proba[k] = np.log(proba[k])\\n\\n return proba\",\n \"def predict_proba(self, inputs):\\n return self.model.predict_proba(inputs)\",\n \"def extract_probs(label, x):\\n\\tb = np.ascontiguousarray(x).view(np.dtype((np.void, x.dtype.itemsize * x.shape[1])))\\n\\tunique_array, unique_indices, unique_inverse_x, unique_counts = \\\\\\n\\t\\tnp.unique(b, return_index=True, return_inverse=True, return_counts=True)\\n\\tunique_a = x[unique_indices]\\n\\tb1 = np.ascontiguousarray(unique_a).view(np.dtype((np.void, unique_a.dtype.itemsize * unique_a.shape[1])))\\n\\tpxs = unique_counts / float(np.sum(unique_counts))\\n\\tp_y_given_x = []\\n\\tfor i in range(0, len(unique_array)):\\n\\t\\tindexs = unique_inverse_x == i\\n\\t\\tpy_x_current = np.mean(label[indexs, :], axis=0)\\n\\t\\tp_y_given_x.append(py_x_current)\\n\\tp_y_given_x = np.array(p_y_given_x).T\\n\\treturn p_y_given_x, b1, b, unique_a, unique_inverse_x, pxs\",\n \"def lnprobability(self):\\n return\",\n \"def outputGenerationProbability(self):\\n self.b = zeros((self.noOfEmmittingStates, self.T))\\n for row in range(self.noOfEmmittingStates):\\n for col in range(self.T):\\n self.b[row, col] = self.gaussianDist(self.observationSequence[0, col],\\n self.outputProbabilities[row, 0],\\n self.outputProbabilities[row, 1])\",\n \"def _get_selection_probabilities(self):\\r\\n probabilities = np.arange(1, self.population_size+1, dtype=float)[::-1]\\r\\n probabilities /= probabilities.sum()\\r\\n return probabilities\",\n \"def uncertain_logits_to_probs(logits):\\n b, n_times_d = logits.size()\\n d = 3\\n if n_times_d % d:\\n raise ValueError('Expected logits dimension to be divisible by {}, got size {}.'.format(d, n_times_d))\\n n = n_times_d // d\\n\\n logits = logits.view(b, n, d)\\n probs = F.softmax(logits[:, :, 1:], dim=-1)\\n probs = probs[:, :, 1]\\n\\n return probs\",\n \"def postprocess(output):\\n text=''\\n order = output.argsort()[::-1][:6]\\n # print('\\\\n------- predictions --------')\\n for i in range(1):\\n # print ('prediction ' + str(i) + ' (probability ' + str(output[order[i]]*100) + '%) is ' + gNetworkCategories[order[i]] + ' label index is: ' + str(order[i]) )\\n text=text+str(gNetworkCategories[order[i]])\\n\\n return text\",\n \"def stdProbabilityNorm(self):\\n B = factorial(self.alpha-1)*factorial(self.beta-1)/factorial(self.alpha+self.beta-1)\\n norm = 1.0/(2**(self.alpha+self.beta-1)*B)\\n return norm\",\n \"def value_predictions(self):\\n return np.array([m['critic'] for m in self.model_outs], dtype=np.float32)\",\n \"def log_prob(self):\\n if not RerankingParser._parser_model_loaded:\\n raise ValueError(\\\"You need to have loaded a parser model in \\\"\\n \\\"order to get the log probability.\\\")\\n return parser.treeLogProb(self._tree)\",\n \"def logit_to_prob(logits: Tensor, criterion):\\n logits = logits.detach()\\n\\n if logits.size(1) == 2:\\n # return logits.softmax()[:, 0:1, ...] # Take probabilities of the first class (salt)\\n return logits.argmax(dim=1).float()\\n elif logits.size(1) == 1:\\n if isinstance(criterion, LovaszHingeLoss) or criterion == 'lovasz':\\n return (logits > 0).float()\\n else:\\n return logits.sigmoid()\\n\\n raise ValueError('Unsupported number of channels')\",\n \"def model_probs(self, classifier=None):\\n if not classifier:\\n classifier = RandomForestClassifier(n_estimators=100, n_jobs=-1)\\n classifier.fit(self.X_train, self.y_train)\\n predictions = classifier.predict_proba(self.X)\\n return predictions\",\n \"def measure_rate(net, n_samples=10):\\n from scipy.stats import multivariate_normal as mn\\n\\n dataset_dir, dataset_pth = make_dataset_pths(net)\\n print(\\\"dataset path: \\\", dataset_pth)\\n X, Probes, Change_prob, Perceptual_dist = load_or_make_dataset(\\n net, dataset_pth, dataset_dir, net.dataset_size)\\n Rx = []\\n mu, logsigma = [], []\\n i = 0\\n while True:\\n if i * net.batch_size > len(X) - 1:\\n break\\n x = X[i * net.batch_size:(i + 1) * net.batch_size]\\n m, ls = net.encode_presample(x, keep_session=True)\\n mu.append(m)\\n logsigma.append(ls)\\n i += 1\\n mu = np.vstack(mu)\\n logsigma = np.vstack(logsigma)\\n print(\\\"Dataset encoded.\\\")\\n z = [\\n mn.rvs(mean=mu[j], cov=np.diag(np.exp(logsigma[j])), size=n_samples)\\n for j in range(len(mu))\\n ]\\n p_z_given_x = [\\n mn.logpdf(z[j], mean=mu[j], cov=np.diag(np.exp(logsigma[j])))\\n for j in range(len(mu))\\n ]\\n m_z = [\\n mn.logpdf(\\n z[j], mean=np.zeros(net.latent_size), cov=np.eye(net.latent_size))\\n for j in range(len(mu))\\n ]\\n Rx = [(p_z_given_x[j] - m_z[j]).sum() / n_samples for j in range(len(mu))]\\n R = sum(Rx) / len(X)\\n print(R)\\n return R\",\n \"def predict_prob(self, _input_data):\\n yhat_probs = (self.merged_model).predict(_input_data, verbose=0)\\n\\n return yhat_probs[:, 0]\",\n \"def pnet_process_per_scale(self, pnet_output, scale):\\n conf = pnet_output['prob1'][0, 1, :, :]\\n (y, x) = np.where(conf >= self.threshold[0])\\n if len(x) == 0:\\n return None\\n stride = 2\\n cell_size = 12\\n bounding_box = np.array([y, x])\\n bb1 = np.around(stride * bounding_box / scale)\\n bb2 = np.around((stride * bounding_box + cell_size - 1) / scale)\\n score = np.array([conf[y, x]])\\n coord = pnet_output['conv4-2'][0]\\n regression = np.array([coord[1, y, x], coord[0, y, x], \\\\\\n coord[3, y, x], coord[2, y, x]])\\n boxes = np.concatenate((bb1, bb2, score, regression), axis=0).T\\n boxes = self.__nms(boxes, 0.5, 'Union')\\n return boxes\",\n \"def predict_proba(self, x):\\n e = self.predict_evidence(x)\\n a = e + self.prior\\n return a / torch.sum(a, dim=-1, keepdim=True)\",\n \"def predict_proba(self, samples):\\n predictions, class_ids = self.__predict(samples)\\n\\n # analyze\\n probabilities = []\\n\\n for class_id, p in predictions.iteritems():\\n probabilities.append(len(p[p > 0]) / float(len(samples)))\\n class_ids.append(class_id)\\n return np.array(probabilities), np.array(class_ids)\",\n \"def clean_outputs(outputs):\\n return [1 if sigmoid(b) > 0.5 else 0 for b in outputs]\",\n \"def p_to_prediction(self, p):\\n if isinstance(p, list):\\n return [self.p_to_prediction(_p) for _p in p]\\n elif isinstance(p, Normal):\\n pred = p.loc.cpu().detach().numpy()\\n elif isinstance(p, Bernoulli):\\n pred = p.probs.cpu().detach().numpy()\\n else:\\n raise NotImplementedError\\n return pred\",\n \"def probability(self, X_):\\n X = np.c_[np.ones(X_.shape[0]), X_] # add bias variable 1\\n prob = np.zeros(X.shape[0], self.num_classes)\\n ### YOUR CODE HERE\\n z = X.dot(self.w)\\n prob = soft_reg.softmax(z)\\n ### END CODE\\n return prob\",\n \"def precision(classifier_output, true_labels):\\n\\n # TODO: finish this.\\n conf_matrix = confusion_matrix(classifier_output, true_labels)\\n return conf_matrix[0][0]/(conf_matrix[0][0] + conf_matrix[1][0])\",\n \"def update_probs(self, measure, p, enemy_net = False):\\n tmp_net = []\\n net_size = len(self.net) \\n if not enemy_net:\\n net = self.net\\n else:\\n net = self.enemy_net\\n #Maps a given color to its corresponding column in the color's \\n #probability table.\\n if measure == GREEN:\\n color = 0\\n elif measure == YELLOW:\\n color = 1\\n elif measure == ORANGE:\\n color = 2\\n elif measure == RED:\\n color = 3\\n #Obtains new probabilities by using the distance between the\\n #observed position (the one measured) and any other position.\\n for j in range(0, net_size):\\n distance = self.__get_distance(p, j)\\n if distance == 0: #When updating the measured position's probability.\\n tmp_net.append(net[j].value * self.ct[0][color])\\n elif distance == 1: #When updating an adjacent position to the one measured.\\n tmp_net.append(net[j].value * self.ct[1][color])\\n elif distance == 2: #When updating a position at two cells from the one measured.\\n tmp_net.append(net[j].value * self.ct[2][color])\\n elif distance == 3: #When updating a position at three cells from the one measured.\\n tmp_net.append(net[j].value * self.ct[3][color])\\n else: #When updating a position at four or more cells from the one measured.\\n tmp_net.append(net[j].value * self.ct[4][color])\\n #Obtains summation of new probabilities in order to execute \\n #a posterior normalization.\\n total = sum(tmp_net)\\n #Normalizes new probabilities and assigns them to its \\n #corresponding position.\\n for i in range(0, net_size):\\n net[i].value = tmp_net[i]/total\",\n \"def _compute_outputs(self, *args, **kwargs):\\n pass\\n # self.outputs = self.model(input_ids=self.input_ids, masked_lm_labels=self.input_ids)\\n # self.logits = self.outputs[0][0]\\n # self.probs = torch.softmax(self.logits, 1)\",\n \"def unnormalizeFromParams(output, norm_params):\\n # for mean in norm_params[0:3]: #take the first three because that's the mean\\n output[0] = (float(output[0]) * float(norm_params[3])) + float(norm_params[0])\\n output[1] = (float(output[1]) * float(norm_params[4])) + float(norm_params[1])\\n output[2] = (float(output[2]) * float(norm_params[5])) + float(norm_params[2])\\n\\n return output\",\n \"def sentence_logprob(self, sentence):\\n line = get_ngrams(sentence,3)\\n log_por = 0.0\\n for item in line:\\n raw_por = self.smoothed_trigram_probability(item)\\n log_por = log_por+math.log2(raw_por)\\n\\n return float(log_por)\",\n \"def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\\n\\n self._check_input_data(X=X)\\n self._check_support(X=X, n=self.n)\\n\\n if not isinstance(self.prob, np.ndarray):\\n log_proba = stats.binom.logpmf(X, n=self.n, p=self.prob)\\n else:\\n n_samples = X.shape[0]\\n n_classes = len(self.prob) # type: ignore\\n log_proba = np.zeros((n_samples, n_classes))\\n\\n for cls in range(n_classes):\\n log_proba[:, cls] = stats.binom.logpmf(X, n=self.n, p=self.prob[cls]) # type: ignore\\n\\n return log_proba\",\n \"def predict_proba(self, X, check_input=True):\\n check_is_fitted(self, 'tree_')\\n X = self._validate_X_predict(X, check_input)\\n proba = self.tree_.predict(X)\\n\\n if self.n_outputs_ == 1:\\n proba = proba[:, :self.n_classes_]\\n normalizer = proba.sum(axis=1)[:, np.newaxis]\\n normalizer[normalizer == 0.0] = 1.0\\n proba /= normalizer\\n\\n return proba\\n\\n else:\\n all_proba = []\\n\\n for k in range(self.n_outputs_):\\n proba_k = proba[:, k, :self.n_classes_[k]]\\n normalizer = proba_k.sum(axis=1)[:, np.newaxis]\\n normalizer[normalizer == 0.0] = 1.0\\n proba_k /= normalizer\\n all_proba.append(proba_k)\\n\\n return all_proba\",\n \"def probOut(self) -> dict:\\n \\n return {\\n j: sum(\\n [ self.mat[i][j] * self.probIn[i] for i in self.simbIn ]\\n ) for j in self.simbOut\\n }\",\n \"def get_nml_probs(x, model, data=None, normalize=True, num_classes=2, query_point_weight=20, dist_weight_thresh=None, \\n num_grad_steps=10, lr=0.01, batch_size=32, grad_penalty=None, verbose=False, \\n show_plots=False, plotting_2d=False, return_params=False):\\n results = []\\n data = data or DEFAULT_DATA\\n orig_inputs, orig_targets = data\\n \\n if show_plots and plotting_2d:\\n plt.figure()\\n plt.title(f\\\"Original rewards\\\")\\n plot_rewards(model, contours=True)\\n plot_dataset(data)\\n \\n marker_for_class = {\\n 0: 'x',\\n 1: '*'\\n }\\n \\n model.cuda()\\n num_batches = ceil(len(orig_inputs) / batch_size)\\n\\n # NOTE train on gpu, move back to cpu for eval\\n \\n for proposed_class in range(num_classes):\\n new_model = copy.deepcopy(model)\\n new_model.cuda()\\n \\n # Sample all of the adaptation batches in advance\\n optimizer = optim.SGD(new_model.parameters(), lr=lr)\\n \\n for _ in range(num_grad_steps):\\n idxs = np.random.permutation(range(len(orig_inputs)))[:batch_size-1]\\n X, y = orig_inputs[idxs], orig_targets[idxs]\\n X = torch.Tensor(np.vstack((X, x))).cuda()\\n y = torch.Tensor(np.hstack((y, proposed_class))).long().cuda()\\n \\n logits = new_model(X)\\n loss = F.cross_entropy(logits, y, reduction='none')\\n \\n if dist_weight_thresh:\\n weights = np.exp(-np.linalg.norm(x - X.cpu().numpy(), axis=-1) * 2.3 / dist_weight_thresh)\\n else:\\n weights = np.ones(len(y))\\n \\n weights[-1] *= query_point_weight * 1. / num_batches\\n weights = torch.Tensor(weights).cuda()\\n loss = torch.sum(loss * weights) / torch.sum(weights)\\n \\n loss.backward()\\n optimizer.step()\\n \\n new_model.cpu()\\n \\n with torch.no_grad():\\n x_tensor = torch.Tensor(x[None])\\n probs = torch.softmax(new_model(x_tensor), -1)\\n results.append(probs[0][proposed_class].item())\\n \\n if show_plots:\\n new_model.to(torch.device(\\\"cpu\\\"))\\n\\n if plotting_2d: \\n plt.figure()\\n plot_rewards(new_model, contours=True, env = False, title=f\\\"Finetuning on label {proposed_class}\\\")\\n plot_dataset(data)\\n plt.scatter(x[0], x[1], marker=marker_for_class[proposed_class], color='w', s=100)\\n \\n plt.figure()\\n plt.title(f\\\"Losses for label {proposed_class}\\\")\\n plt.plot(losses)\\n \\n plt.figure()\\n plt.title(f\\\"x loss for label {proposed_class}\\\")\\n plt.plot(x_losses)\\n \\n plt.figure()\\n plt.title(f\\\"x probs for label {proposed_class}\\\")\\n plt.plot(x_vals)\\n \\n model.cpu()\\n \\n if normalize:\\n results = np.array(results) / sum(results)\\n else:\\n results = np.array(results)\\n return results if not return_params else (results, new_model)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7654916","0.762612","0.7447698","0.7434408","0.7308484","0.72212243","0.65518427","0.61370546","0.61370546","0.6102418","0.6070036","0.60151446","0.59467596","0.5924957","0.58652586","0.58567977","0.57644725","0.5761727","0.5735097","0.57293767","0.572784","0.5710415","0.5695496","0.5679793","0.5677949","0.5671762","0.5658122","0.5648089","0.5624334","0.5613419","0.5598712","0.5593342","0.5556606","0.5552612","0.5538948","0.5537085","0.5533109","0.5528071","0.5508658","0.54947287","0.54768","0.54745","0.5453816","0.5445929","0.5445492","0.54390854","0.5422832","0.5405226","0.54001635","0.5396324","0.53480273","0.5340865","0.53340816","0.5333145","0.5327947","0.53086084","0.52958965","0.52928394","0.52923894","0.5288441","0.528407","0.5277052","0.52708995","0.5270047","0.5270043","0.52656215","0.526358","0.52585286","0.5252191","0.5249482","0.52442074","0.52338403","0.52271575","0.52120584","0.52111405","0.520559","0.5192135","0.5188103","0.51804954","0.5164827","0.51643413","0.5163705","0.5157648","0.5157542","0.51479316","0.5146631","0.513834","0.5137891","0.51247686","0.5123877","0.51199836","0.51144433","0.51121116","0.5109703","0.5105466","0.5105245","0.5101499","0.5100852","0.5097915"],"string":"[\n \"0.7654916\",\n \"0.762612\",\n \"0.7447698\",\n \"0.7434408\",\n \"0.7308484\",\n \"0.72212243\",\n \"0.65518427\",\n \"0.61370546\",\n \"0.61370546\",\n \"0.6102418\",\n \"0.6070036\",\n \"0.60151446\",\n \"0.59467596\",\n \"0.5924957\",\n \"0.58652586\",\n \"0.58567977\",\n \"0.57644725\",\n \"0.5761727\",\n \"0.5735097\",\n \"0.57293767\",\n \"0.572784\",\n \"0.5710415\",\n \"0.5695496\",\n \"0.5679793\",\n \"0.5677949\",\n \"0.5671762\",\n \"0.5658122\",\n \"0.5648089\",\n \"0.5624334\",\n \"0.5613419\",\n \"0.5598712\",\n \"0.5593342\",\n \"0.5556606\",\n \"0.5552612\",\n \"0.5538948\",\n \"0.5537085\",\n \"0.5533109\",\n \"0.5528071\",\n \"0.5508658\",\n \"0.54947287\",\n \"0.54768\",\n \"0.54745\",\n \"0.5453816\",\n \"0.5445929\",\n \"0.5445492\",\n \"0.54390854\",\n \"0.5422832\",\n \"0.5405226\",\n \"0.54001635\",\n \"0.5396324\",\n \"0.53480273\",\n \"0.5340865\",\n \"0.53340816\",\n \"0.5333145\",\n \"0.5327947\",\n \"0.53086084\",\n \"0.52958965\",\n \"0.52928394\",\n \"0.52923894\",\n \"0.5288441\",\n \"0.528407\",\n \"0.5277052\",\n \"0.52708995\",\n \"0.5270047\",\n \"0.5270043\",\n \"0.52656215\",\n \"0.526358\",\n \"0.52585286\",\n \"0.5252191\",\n \"0.5249482\",\n \"0.52442074\",\n \"0.52338403\",\n \"0.52271575\",\n \"0.52120584\",\n \"0.52111405\",\n \"0.520559\",\n \"0.5192135\",\n \"0.5188103\",\n \"0.51804954\",\n \"0.5164827\",\n \"0.51643413\",\n \"0.5163705\",\n \"0.5157648\",\n \"0.5157542\",\n \"0.51479316\",\n \"0.5146631\",\n \"0.513834\",\n \"0.5137891\",\n \"0.51247686\",\n \"0.5123877\",\n \"0.51199836\",\n \"0.51144433\",\n \"0.51121116\",\n \"0.5109703\",\n \"0.5105466\",\n \"0.5105245\",\n \"0.5101499\",\n \"0.5100852\",\n \"0.5097915\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78670233"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":23999,"cells":{"query":{"kind":"string","value":"Scriptable helper function for get_normalized_probs in ~BaseFairseqModel"},"document":{"kind":"string","value":"def get_normalized_probs_scriptable(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]] = None,\n ):\n if hasattr(self, \"decoder\"):\n return self.decoder.get_normalized_probs(net_output, log_probs, sample)\n elif torch.is_tensor(net_output):\n # syntactic sugar for simple models which don't have a decoder\n # (e.g., the classification tutorial)\n logits = net_output.float()\n if log_probs:\n return F.log_softmax(logits, dim=-1)\n else:\n return F.softmax(logits, dim=-1)\n raise NotImplementedError"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def normalize_to_prob(inp):\n return (inp + 1)/2","def get_normalized_probs(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]] = None,\n ):\n return self.get_normalized_probs_scriptable(net_output, log_probs, sample)","def get_normalized_probs(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]] = None,\n ):\n return self.get_normalized_probs_scriptable(net_output, log_probs, sample)","def get_normalized_probs(self, net_output, log_probs):\n logits = net_output\n if log_probs:\n return F.log_softmax(logits, dim=1)\n else:\n return F.softmax(logits, dim=1)","def normalize(init_probs):\n total_prob = sum(init_probs)\n if total_prob > 0. + InferenceUtils._eps:\n for idx in range(len(init_probs)):\n init_probs[idx] = init_probs[idx] / total_prob\n\n # TODO: check refactor > do we have to return distrib with new instance?\n return init_probs","def get_pred_class_probs(self, pred_mu, pred_sigma):","def stdProbabilityNorm(self):\n return 0.5","def get_normalized_probs(self, net_output, log_probs, sample=None):\n encoder_out = net_output[\"encoder_out\"]\n if torch.is_tensor(encoder_out):\n logits = encoder_out.float()\n if log_probs:\n return F.log_softmax(logits, dim=-1)\n else:\n return F.softmax(logits, dim=-1)\n raise NotImplementedError","def normalize_probability(p_unnormalized):\n p_normalized=p_unnormalized/p_unnormalized.sum(axis=0)\n return p_normalized","def get_nml_probs(x, model, data=None, normalize=True, num_classes=2, query_point_weight=20, dist_weight_thresh=None, \n num_grad_steps=10, lr=0.01, batch_size=32, grad_penalty=None, verbose=False, \n show_plots=False, plotting_2d=False, return_params=False):\n results = []\n data = data or DEFAULT_DATA\n orig_inputs, orig_targets = data\n \n if show_plots and plotting_2d:\n plt.figure()\n plt.title(f\"Original rewards\")\n plot_rewards(model, contours=True)\n plot_dataset(data)\n \n marker_for_class = {\n 0: 'x',\n 1: '*'\n }\n \n model.cuda()\n num_batches = ceil(len(orig_inputs) / batch_size)\n\n # NOTE train on gpu, move back to cpu for eval\n \n for proposed_class in range(num_classes):\n new_model = copy.deepcopy(model)\n new_model.cuda()\n \n # Sample all of the adaptation batches in advance\n optimizer = optim.SGD(new_model.parameters(), lr=lr)\n \n for _ in range(num_grad_steps):\n idxs = np.random.permutation(range(len(orig_inputs)))[:batch_size-1]\n X, y = orig_inputs[idxs], orig_targets[idxs]\n X = torch.Tensor(np.vstack((X, x))).cuda()\n y = torch.Tensor(np.hstack((y, proposed_class))).long().cuda()\n \n logits = new_model(X)\n loss = F.cross_entropy(logits, y, reduction='none')\n \n if dist_weight_thresh:\n weights = np.exp(-np.linalg.norm(x - X.cpu().numpy(), axis=-1) * 2.3 / dist_weight_thresh)\n else:\n weights = np.ones(len(y))\n \n weights[-1] *= query_point_weight * 1. / num_batches\n weights = torch.Tensor(weights).cuda()\n loss = torch.sum(loss * weights) / torch.sum(weights)\n \n loss.backward()\n optimizer.step()\n \n new_model.cpu()\n \n with torch.no_grad():\n x_tensor = torch.Tensor(x[None])\n probs = torch.softmax(new_model(x_tensor), -1)\n results.append(probs[0][proposed_class].item())\n \n if show_plots:\n new_model.to(torch.device(\"cpu\"))\n\n if plotting_2d: \n plt.figure()\n plot_rewards(new_model, contours=True, env = False, title=f\"Finetuning on label {proposed_class}\")\n plot_dataset(data)\n plt.scatter(x[0], x[1], marker=marker_for_class[proposed_class], color='w', s=100)\n \n plt.figure()\n plt.title(f\"Losses for label {proposed_class}\")\n plt.plot(losses)\n \n plt.figure()\n plt.title(f\"x loss for label {proposed_class}\")\n plt.plot(x_losses)\n \n plt.figure()\n plt.title(f\"x probs for label {proposed_class}\")\n plt.plot(x_vals)\n \n model.cpu()\n \n if normalize:\n results = np.array(results) / sum(results)\n else:\n results = np.array(results)\n return results if not return_params else (results, new_model)","def normalize_transform():\n\n # Default for PyTorch's pre-trained models\n return transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])","def get_probs(self, a):\n with torch.no_grad():\n probabilities = (np.array(self.priorities) ** a) / sum(np.array(self.priorities) ** a)\n return probabilities","def model_probs(self, classifier=None):\n if not classifier:\n classifier = RandomForestClassifier(n_estimators=100, n_jobs=-1)\n classifier.fit(self.X_train, self.y_train)\n predictions = classifier.predict_proba(self.X)\n return predictions","def predictability(self):\n temp = self.probs\n for n in range(10):\n temp = temp.dot(temp)\n final = temp[0,:]\n #Let's assume that all words have unique initial letters\n probs = map(len, self.words)\n probs = array(probs)\n probs = (probs + self.probs.max(1)-1)/probs\n return sum(final*probs)","def normalized(self) -> 'NormalizedFXParam':\r\n ...","def test_compute_unnormalized_scores(self):\n # todo: implement this test!\n pass","def get_normalized_probabilities(self, begin_date):\n probs_df = self.data_provider.get_probs_df(begin_date)\n\n if probs_df.empty:\n raise OptimizationException(\"There are no investment clock predictions available\")\n sum_row = probs_df.sum(axis=1)\n norm_probs = probs_df.div(sum_row, axis=0)\n return norm_probs","def get_normalized_probs(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]] = None,\n ):\n\n if hasattr(self, \"adaptive_softmax\") and self.adaptive_softmax is not None:\n if sample is not None:\n assert \"target\" in sample\n target = sample[\"target\"]\n else:\n target = None\n out = self.adaptive_softmax.get_log_prob(net_output[0], target=target)\n return out.exp_() if not log_probs else out\n\n logits = net_output[0]\n if log_probs:\n return log_softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\n else:\n return softmax(logits, dim=-1, onnx_trace=self.onnx_trace)","def get_normalized_probs(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]],\n ):\n\n if hasattr(self, \"adaptive_softmax\") and self.adaptive_softmax is not None:\n if sample is not None:\n assert \"target\" in sample\n target = sample[\"target\"]\n else:\n target = None\n out = self.adaptive_softmax.get_log_prob(net_output[0], target=target)\n return out.exp_() if not log_probs else out\n\n logits = net_output[0]\n if log_probs:\n return utils.log_softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\n else:\n return utils.softmax(logits, dim=-1, onnx_trace=self.onnx_trace)","def normalize(self, arr):\r\n\r\n\t\t#Set the cap for arr at self.value_max and self.value_max\r\n\t\t#this prevents outliers of breaking the previously predicted p_func\r\n\t\tarr_capped = arr * (arr <= self.value_max) + self.value_max * (arr > self.value_max)\t#cap to value_max\r\n\t\tarr_capped = arr_capped * (arr_capped >= self.value_min) + self.value_min * (arr_capped < self.value_min)\t#cap to value_min\r\n\r\n\t\t#Normalize array\r\n\t\tnorm_factor = self.get_norm_factor(arr_capped)\r\n\t\tnormalized = arr * norm_factor\r\n\r\n\t\treturn(normalized)","def normalize(probabilities):\n for person in probabilities:\n\n # normalize the \"gene\"\n geneSum = probabilities[person][\"gene\"][0] + probabilities[person][\"gene\"][1] + probabilities[person][\"gene\"][2]\n for i in range(3):\n probabilities[person][\"gene\"][i] /= geneSum\n\n # normalize the \"trait\"\n traitSum = probabilities[person][\"trait\"][True] + probabilities[person][\"trait\"][False]\n probabilities[person][\"trait\"][True] /= traitSum\n probabilities[person][\"trait\"][False] /= traitSum","def u_probs(self):\n log_u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\n\n return self._prob_inverse_transform(numpy.exp(log_u))","def stdProbabilityNorm(self):\n return 1./factorial(self.alpha-1)","def _normalize(self, inp):\n \n return inp/inp.sum()","def normalize_label(labels):\n max_val = torch.max(labels)\n min_val = torch.min(labels)\n norm_labels = (labels - min_val)/(max_val - min_val)\n return norm_labels","def __get_net_probs(self):\n return np.array([node.value for node in self.net]).reshape(5,5)","def normalize(audio):\n norm = audio/max(audio)\n return norm","def mixed_prob( means,stds,weights,validt):","def edit_probs(result):\n for i in range(TOP_E):\n p = result.data[i][1]\n p = round(p, 4)\n # p_str = str(p)[1:]\n result.data[i][1] = p\n\n return result","def norm_experiment():\n print(\"NORM_EXPERIMENT\")\n\n # set the name of the experiment\n now = datetime.datetime.now()\n experiment_id = str(now.day) + \"_\" + str(now.month) + \"_\" + str(now.hour) + \".\" + str(now.minute)\n experiment_name = 'normalization_' + str(experiment_id)\n\n # define if you want to use preprocessed data from file\n use_prep_data = False\n if use_prep_data:\n set_params(preproc_data_id='16_5_10.16.47')\n else:\n set_params(use_preproc_data=False)\n\n # define the changing parameter and its value\n changing_param_name = 'NORMALIZE'\n changing_param_value = [1, 0]\n # , {0:4, 1:100}, {0:3, 1:100}, {0:2, 1:100}, {0:1, 1:100}] #[{0:1, 1:1}, {0:15, 1:85}]#\n\n # set constant parameters\n set_params(epochs=20)\n set_params(dropout=0.3)\n set_params(use_word_emb=1)\n\n # save constant parameters to a new \"experiment_..\" file\n save_constant_parameters(experiment_name, changing_param_name)\n\n # run experiment for every parameter value\n for value in changing_param_value:\n\n # update the parameter value\n set_params(normalize = value)\n\n # update the model_id for this new model\n now = datetime.datetime.now()\n new_model_id = str(now.day) + \"_\" + str(now.month) + \"_\" + str(now.hour) + \".\" + str(now.minute) + \".\" + str(now.second)\n set_params(model_id = new_model_id)\n\n # evaluate the new model and save the results in the experiment file\n oneExperiment = Process(target=run_experiment, args=(experiment_name, new_model_id, changing_param_name, value,))\n oneExperiment.start()\n oneExperiment.join()","def predict_proba(self, inputs):\n return self.model.predict_proba(inputs)","def normalize_parameters(self):\n self.entity_embeddings.weight.data = normalize(self.entity_embeddings.weight.data,\n p=self.norm_type, dim=1)","def model_normalize_(self, ref_point: 'ModelParameters', order=2):\n for parameter in self.parameters:\n parameter *= (ref_point.model_norm(order) / self.model_norm())","def __normalize(input, type, a, b):\n return cv2.normalize(input, None, a, b, type)","def priorProbabilities():\r\n\ttotal = 0.0\r\n\tpos = 0.0\r\n\tneg = 0.0\r\n\r\n\t# Count the amount of positives and negatives in the training data\r\n\tfor item in trainingData:\r\n\t\ttotal += 1\r\n\t\tif item[1] == '0':\r\n\t\t\tpos +=1\r\n\t\tif item[1] == '1':\r\n\t\t\tneg +=1\r\n\t\t\t\r\n\t\t\t\r\n\t# Return the positive and negative probabilities \r\n\tposProb = float(pos / total * 100)\r\n\tnegProb = float(neg / total * 100)\r\n\r\n\t\r\n\t\r\n\treturn posProb, negProb","def get_probs(self, states, actions):\n # YOUR CODE HERE\n \n probs = np.ones(len(states))/2\n return probs","def calc_prob_local(self, *args):\n return 0","def norm(self):","def predict_proba(X, classifier):\n prob = np.dot(X, classifier['coef_'].T) + classifier['intercept_']\n prob = prob.ravel() if prob.shape[1] == 1 else prob\n prob *= -1\n np.exp(prob, prob)\n prob += 1\n np.reciprocal(prob, prob)\n if prob.ndim == 1:\n return np.vstack([1 - prob, prob]).T\n else:\n # OvR normalization, like LibLinear's predict_probability\n prob /= prob.sum(axis=1).reshape((prob.shape[0], -1))\n return prob","def probabilities(self):\n raise NotImplementedError","def predict_proba(self):\n ...","def set_uniform_probabilities(self, sentence_aligned_corpus):\n ...","def norm(self):\n # TODO: implement\n return","def normalize(self, factor):","def get_probs(self, *vars):\n freqs = self.freq_counts([self.data.get_column_view(v)[0] for v in vars], [len(v.values) for v in vars])\n k = np.prod([len(v.values) for v in vars])\n return (freqs + self.alpha) / (np.sum(freqs) + self.alpha*k)","def m_probs(self):\n log_m = self.kernel.feature_log_prob_[self._match_class_pos()]\n\n return self._prob_inverse_transform(numpy.exp(log_m))","def set_proba(self):\n self.__c_elem().log_normalise()","def _compute_model_prob(self, per_list_logodds):\n with tf.compat.v1.name_scope(name='compute_model_prob'):\n return tf.stop_gradient(\n tf.exp(-self._alpha *\n (per_list_logodds -\n tf.reduce_min(per_list_logodds, axis=2, keepdims=True))))","def uniform_start_probs(self) -> np.ndarray:\n return np.ones(self.n_states) / self.n_states","def normalize(distrib):\n if isinstance(distrib, dict):\n total_prob = sum(distrib.values())\n if total_prob <= 0.:\n # TODO: check bug > is this a sufficient condition for the error cases?\n # TODO: check bug > Is just returning distrib enough?\n InferenceUtils.log.warning(\"all assignments in the distribution have a zero probability, cannot be normalised\")\n return distrib\n\n for key, value in distrib.items():\n distrib[key] = distrib[key] / total_prob\n return distrib","def _get_model_priors(self):\n if self._alpha_model_priors:\n return self._alpha_model_priors\n # sample the variables from their corresponding distributions\n params = self._get_prior_params()\n self._alpha_model_priors = self._params2probs(params)\n return self._alpha_model_priors","def normalize_parameters(self):\n self.entity_embeddings.weight.data = normalize(self.entity_embeddings.weight.data,\n p=self.norm_type, dim=1)\n self.normal_vectors.data = normalize(self.normal_vectors, p=2, dim=1)","def normalize(x):\r\n return x/norm(x)","def unnormalized_loss(self):\n return 0.5 * la.norm(self.resids) ** 2","def normalized(self):\n return self / self.norm()","def predict_proba(self):\n if self.rank_prob is None:\n raise ValueError('No results available. Did you already call predict(...)?')\n\n return np.array([sum(map(lambda x: x[1], result)) / len(result) for result in self.rank_prob])","def predict_proba(self, x):\n e = self.predict_evidence(x)\n a = e + self.prior\n return a / torch.sum(a, dim=-1, keepdim=True)","def normalize_parameters(self):\n self.entity_embeddings.weight.data = normalize(self.entity_embeddings.weight.data,\n p=2, dim=1)\n self.relation_embeddings.weight.data = normalize(self.relation_embeddings.weight.data,\n p=2, dim=1)\n self.ent_proj_vects.data = normalize(self.ent_proj_vects.data, p=2, dim=1)\n self.rel_proj_vects.data = normalize(self.rel_proj_vects.data, p=2, dim=1)","def log_u_probs(self):\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\n return self._prob_inverse_transform(u)","def probs(self) -> List:\n return self._probs","def predict(probs):\n # Your code here.\n return np.argmax(probs, axis=1)","def normalize_input(inputs: [float]) -> [float]:","def imgNormalize(img): \n constant = np.sum(sitk.GetArrayFromImage(img))*np.prod(img.GetSpacing())\n return img/constant","def normalize(vals):\n min_val = torch.min(vals)\n max_val = torch.max(vals)\n return (vals - min_val) / (max_val - min_val)","def normalization(seq):\n\t\tnew_seq = [6.3578286171 * x for x in seq]\n\t\treturn new_seq","def get_normalize(self):\n return self.normalize","def normalize(p,L): \r\n Norm = []\r\n for k in L:\r\n x = k - p\r\n norm = x.dot(x)**0.5\r\n if norm != 0:\r\n Norm.append(x/norm)\r\n else:\r\n print('warning: attempt to normalize 0')\r\n \r\n return Norm","def naive_bn(data, attributes):\n bn = []\n attr = attributes['attr'].tolist()\n # each attribute is only dependent on the class node\n i = 0\n while (i < len(attr)-1):\n row = [attr[i], attr[-1]]\n bn.append(row)\n i= i + 1\n # frequency table \n freq = counts_table(data, attributes)\n # conditional probabilities and prior probabilities\n cond_probs, prior0, prior1 = conditional_probability(data, attributes, freq)\n\n return bn, cond_probs, prior0, prior1","def predict_probability_model(*args):\n final_data = None\n any_null = validate_none(args)\n if any_null:\n final_data = transform_fields(args[-3:])\n final_data = list(args[0:5]) + final_data\n predicted = test_model(final_data)\n converts, styles = user_converts(predicted)\n\n return [f'{predicted} %', converts] + styles","def normalize(inp):\n\n out = inp / np.linalg.norm(inp, axis=1, keepdims=True)\n\n return out","def NormalizePhenotypeScore(score, max_score):\n return float(score) / float(max_score) * 100","def probs(self):\n warnings.warn(\n \"VqeResult.probs is obsoleted. \" + \"Use VqeResult.get_probs().\",\n DeprecationWarning)\n return self.get_probs()","def MakePredictiveDist(self):\n raw_pmf = self.exam.MakeRawScoreDist(self)\n return raw_pmf","def normalize(sequence):\n return [_norm(s) for s in sequence]","def log_probs(self):\n return np.array([m['log_probs'] for m in self.model_outs], dtype=np.float32)","def get_raw_probability(self):\n\t\tproba = RunOrder.BASE_SUCCESS_PROBABILITY\n\t\tproba += (self.additional_percents + self.hidden_percents) * 10\n\t\treturn proba","def get_probs(self):\n\t\tprobArray = []\n\t\tfor combination in self.codepool:\n\t\t\tif self.feasible(combination):\n\t\t\t\tprobArray.append(self.get_probability(combination))\n\t\t\telse:\n\t\t\t\tprobArray.append(0)\n\t\tprobArray = np.array(probArray) / np.sum(probArray)\n\t\treturn probArray","def prior(mu):\n p = np.ones(len(mu))/(mu.max()-mu.min())\n return p","def _compute_input_normalization(*amps):\n if len(amps) < 2:\n raise ValueError('At least 2 amplitudes must be provided.')\n n_bosons = len(amps)\n left_range = range(n_bosons)\n right_ranges = list(itertools.permutations(left_range))\n total = 0.\n for right_range in right_ranges:\n i_prod = 1.\n for idx1, idx2 in zip(left_range, right_range):\n # if `idx1` and `idx2` are equal the contribution is given\n # by the inner product of an amplitude with itself. Given\n # that we are assuming the amplitudes to be normalized,\n # the result is always 1 and we can just skip it\n if idx1 == idx2:\n pass\n # otherwise we update the partial product computing the\n # inner product of the two relevant amplitudes (states)\n i_prod *= np.vdot(amps[idx1], amps[idx2])\n total += i_prod\n return np.sqrt(total)","def stdProbabilityNorm(self):\n B = factorial(self.alpha-1)*factorial(self.beta-1)/factorial(self.alpha+self.beta-1)\n norm = 1.0/(2**(self.alpha+self.beta-1)*B)\n return norm","def raw_unigram_probability(self, unigram):\n result = 0.0\n result = self.unigramcounts[unigram]/self.total\n\n #hint: recomputing the denominator every time the method is called\n # can be slow! You might want to compute the total number of words once, \n # store in the TrigramModel instance, and then re-use it. \n\n\n return result","def __calculateNormalizedScores(self):\n year_scores = {0 : []}\n for venue in self.venue_scores:\n v_scores = []\n for year in self.venue_scores[venue]:\n v_scores.append(self.venue_scores[venue][year])\n if year not in year_scores:\n year_scores[year] = []\n year_scores[year].append(self.venue_scores[venue][year])\n x_year = np.average(np.array(v_scores))\n self.venue_scores[venue][0] = x_year\n year_scores[0].append(x_year)\n \n ##for standardization\n #year_metrics = {x : (np.average(np.array(year_scores[x])), np.std(np.array(year_scores[x]))) for x in year_scores}\n ##for normalization\n year_metrics = {x: (max(year_scores[x]), min(year_scores[x])) for x in year_scores}\n \n #print year_metrics\n \n for venue in self.venue_scores:\n self.normalized_scores[venue] = dict()\n for year in self.venue_scores[venue]:\n #self.standard_scores[venue][year] = round((self.venue_scores[venue][year] - year_metrics[year][0]) / year_metrics[year][1],5)\n #self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1]) / (year_metrics[year][0] - year_metrics[year][1]) + eps\n self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1] + self.epsilon) / (year_metrics[year][0] - year_metrics[year][1] + self.epsilon)","def normalize(vec):\n return vec / length(vec)","def predict_for_items(self, norm=True):\n pred = self.item_vectors.dot(self.item_vectors.T)\n if norm:\n norms = np.array([np.sqrt(np.diagonal(pred))])\n pred = pred / norms / norms.T\n return pred","def _get_prob(self, a, b=1.0):\n p = self.prior\n return (p * a) / ((1-p)*b + p*a)","def normalize_profile(ph):\n return ph/np.abs(ph[1])","def log_m_probs(self):\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\n return self._prob_inverse_transform(m)","def normalize(attributions):\n # keepdims for division broadcasting\n total = np.abs(attributions).sum(axis=1, keepdims=True)\n\n return np.abs(attributions) / total","def normalize(cls, raw_score):\n return super().normalize(raw_score)","def normalize(cls, raw_score):\n return super().normalize(raw_score)","def normalize(cls, raw_score):\n return super().normalize(raw_score)","def normalize(cls, raw_score):\n return super().normalize(raw_score)","def probability_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\n logits = args.attribution_model.output2logits(args.forward_output)\n target_ids = args.target_ids.reshape(logits.shape[0], 1)\n logits = logits.softmax(dim=-1)\n # Extracts the ith score from the softmax output over the vocabulary (dim -1 of the logits)\n # where i is the value of the corresponding index in target_ids.\n return logits.gather(-1, target_ids).squeeze(-1)","def sentiment_score(text, loaded_model = loaded_model, vectorizer = tokenizer):\n # tweet_tf_idf = vect_char.transform(text)\n tweet_token = tokenizer.texts_to_sequences(text)\n tweet_token = pad_sequences(tweet_token, maxlen = 40)\n sentiment = loaded_model.predict_proba(tweet_token)\n neg_prob = sentiment[0][0]\n pos_prob = sentiment[0][1]\n return neg_prob, pos_prob","def normalize(scores, default_score):\n if len(scores) > 0:\n max_scores = max(scores)\n min_scores = min(scores)\n\n if max_scores == min_scores:\n return [default_score] * len(scores)\n scores = [float((score - min_scores) / (max_scores - min_scores)) for score in scores]\n return scores\n else:\n return [default_score]","def _process(self, data: np.ndarray) -> np.ndarray:\n nominals = unp.nominal_values(data)\n min_y, max_y = np.min(nominals), np.max(nominals)\n\n return (data - min_y) / (max_y - min_y)","def probability_of_default(model, prediction_features):\n return model.predict_proba(prediction_features)[:, 1]","def preloadPositivityClassifier():\n Sentience.__DEF_PROB_THRESHOLD = getSentencePositivity(\"!@#$%^&*\")","def naiveBayesMixture(train_set, train_labels, dev_set, bigram_lambda,unigram_smoothing_parameter, bigram_smoothing_parameter, pos_prior):\n\n # TODO: Write your code here\n # return predicted labels of development set\n\n # counters for Training Phase\n ham = Counter()\n ham_bi = Counter()\n spam = Counter()\n spam_bi = Counter()\n\n for string, label in zip(train_set, train_labels):\n for i in range(len(string)):\n word = string[i]\n if i != len(string)-1:\n word_bi = string[i] + ' ' + string[i+1]\n if label == 1:\n ham_bi.update({word_bi:1})\n else:\n spam_bi.update({word_bi:1})\n if label == 1:\n ham.update({word:1})\n else:\n spam.update({word:1})\n\n ham_len = 0\n for w in ham:\n ham_len += ham[w]\n spam_len = 0\n for w in spam:\n spam_len += spam[w]\n \n hambi_len = 0\n for w in ham_bi:\n hambi_len += ham_bi[w]\n spambi_len = 0\n for w in spam_bi:\n spambi_len += spam_bi[w]\n\n # labels for Development Phase\n dev_labels = []\n # dicts for P(word|ham) and P(word|spam)\n p_ham = {}\n p_spam = {}\n p_hambi = {}\n p_spambi = {}\n\n # develop likelihoods based on dev_set\n for word in ham:\n numerator = ham[word] + unigram_smoothing_parameter\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\n p_ham[word] = numerator / denominator\n for word in spam:\n numerator = spam[word] + unigram_smoothing_parameter\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\n p_spam[word] = numerator / denominator\n\n for word_bi in ham_bi:\n numerator = ham_bi[word_bi] + bigram_smoothing_parameter\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\n p_hambi[word_bi] = numerator / denominator\n for word_bi in spam_bi:\n numerator = spam_bi[word_bi] + bigram_smoothing_parameter\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\n p_spambi[word_bi] = numerator / denominator\n \n numerator = unigram_smoothing_parameter\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\n p_ham_zero = numerator / denominator\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\n p_spam_zero = numerator / denominator\n\n numerator = bigram_smoothing_parameter\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\n p_hambi_zero = numerator / denominator\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\n p_spambi_zero = numerator / denominator\n\n for string in dev_set:\n p_words_ham = math.log(pos_prior)\n p_words_spam = math.log(1 - pos_prior)\n\n p_words_hambi = math.log(pos_prior)\n p_words_spambi = math.log(1 - pos_prior)\n \n for i in range(len(string)):\n word = string[i]\n if word in p_ham:\n p_words_ham += math.log(p_ham[word])\n else:\n p_words_ham += math.log(p_ham_zero)\n if word in p_spam:\n p_words_spam += math.log(p_spam[word])\n else:\n p_words_spam += math.log(p_spam_zero)\n\n if i != len(string)-1:\n word_bi = string[i] + ' ' + string[i+1]\n if word_bi in p_hambi:\n p_words_hambi += math.log(p_hambi[word_bi])\n else:\n p_words_hambi += math.log(p_hambi_zero)\n if word_bi in p_spambi:\n p_words_spambi += math.log(p_spambi[word_bi])\n else:\n p_words_spambi += math.log(p_spambi_zero)\n\n p_ham_mix = p_words_ham*(1-bigram_lambda) + p_words_hambi*bigram_lambda\n p_spam_mix = p_words_spam*(1-bigram_lambda) + p_words_spambi*bigram_lambda\n\n dev_labels.append(p_ham_mix >= p_spam_mix)\n\n return dev_labels","def normalized_quantile_loss(actuals: torch.Tensor, predictions: torch.Tensor, quantiles: List[float] = None) -> torch.Tensor:\n normalizer = torch.sum(abs(actuals))\n if quantiles == None:\n QL = QuantileLoss(quantiles=[0.1, 0.5, 0.9])\n else:\n QL = QuantileLoss(quantiles=quantiles)\n\n q_loss = QL.loss(y_pred = predictions, target = actuals)\n reduced_q_loss = torch.sum(q_loss.reshape(-1, q_loss.shape[-1]), 0)\n normalized_loss = 2 * reduced_q_loss / normalizer\n return normalized_loss"],"string":"[\n \"def normalize_to_prob(inp):\\n return (inp + 1)/2\",\n \"def get_normalized_probs(\\n self,\\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\\n log_probs: bool,\\n sample: Optional[Dict[str, Tensor]] = None,\\n ):\\n return self.get_normalized_probs_scriptable(net_output, log_probs, sample)\",\n \"def get_normalized_probs(\\n self,\\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\\n log_probs: bool,\\n sample: Optional[Dict[str, Tensor]] = None,\\n ):\\n return self.get_normalized_probs_scriptable(net_output, log_probs, sample)\",\n \"def get_normalized_probs(self, net_output, log_probs):\\n logits = net_output\\n if log_probs:\\n return F.log_softmax(logits, dim=1)\\n else:\\n return F.softmax(logits, dim=1)\",\n \"def normalize(init_probs):\\n total_prob = sum(init_probs)\\n if total_prob > 0. + InferenceUtils._eps:\\n for idx in range(len(init_probs)):\\n init_probs[idx] = init_probs[idx] / total_prob\\n\\n # TODO: check refactor > do we have to return distrib with new instance?\\n return init_probs\",\n \"def get_pred_class_probs(self, pred_mu, pred_sigma):\",\n \"def stdProbabilityNorm(self):\\n return 0.5\",\n \"def get_normalized_probs(self, net_output, log_probs, sample=None):\\n encoder_out = net_output[\\\"encoder_out\\\"]\\n if torch.is_tensor(encoder_out):\\n logits = encoder_out.float()\\n if log_probs:\\n return F.log_softmax(logits, dim=-1)\\n else:\\n return F.softmax(logits, dim=-1)\\n raise NotImplementedError\",\n \"def normalize_probability(p_unnormalized):\\n p_normalized=p_unnormalized/p_unnormalized.sum(axis=0)\\n return p_normalized\",\n \"def get_nml_probs(x, model, data=None, normalize=True, num_classes=2, query_point_weight=20, dist_weight_thresh=None, \\n num_grad_steps=10, lr=0.01, batch_size=32, grad_penalty=None, verbose=False, \\n show_plots=False, plotting_2d=False, return_params=False):\\n results = []\\n data = data or DEFAULT_DATA\\n orig_inputs, orig_targets = data\\n \\n if show_plots and plotting_2d:\\n plt.figure()\\n plt.title(f\\\"Original rewards\\\")\\n plot_rewards(model, contours=True)\\n plot_dataset(data)\\n \\n marker_for_class = {\\n 0: 'x',\\n 1: '*'\\n }\\n \\n model.cuda()\\n num_batches = ceil(len(orig_inputs) / batch_size)\\n\\n # NOTE train on gpu, move back to cpu for eval\\n \\n for proposed_class in range(num_classes):\\n new_model = copy.deepcopy(model)\\n new_model.cuda()\\n \\n # Sample all of the adaptation batches in advance\\n optimizer = optim.SGD(new_model.parameters(), lr=lr)\\n \\n for _ in range(num_grad_steps):\\n idxs = np.random.permutation(range(len(orig_inputs)))[:batch_size-1]\\n X, y = orig_inputs[idxs], orig_targets[idxs]\\n X = torch.Tensor(np.vstack((X, x))).cuda()\\n y = torch.Tensor(np.hstack((y, proposed_class))).long().cuda()\\n \\n logits = new_model(X)\\n loss = F.cross_entropy(logits, y, reduction='none')\\n \\n if dist_weight_thresh:\\n weights = np.exp(-np.linalg.norm(x - X.cpu().numpy(), axis=-1) * 2.3 / dist_weight_thresh)\\n else:\\n weights = np.ones(len(y))\\n \\n weights[-1] *= query_point_weight * 1. / num_batches\\n weights = torch.Tensor(weights).cuda()\\n loss = torch.sum(loss * weights) / torch.sum(weights)\\n \\n loss.backward()\\n optimizer.step()\\n \\n new_model.cpu()\\n \\n with torch.no_grad():\\n x_tensor = torch.Tensor(x[None])\\n probs = torch.softmax(new_model(x_tensor), -1)\\n results.append(probs[0][proposed_class].item())\\n \\n if show_plots:\\n new_model.to(torch.device(\\\"cpu\\\"))\\n\\n if plotting_2d: \\n plt.figure()\\n plot_rewards(new_model, contours=True, env = False, title=f\\\"Finetuning on label {proposed_class}\\\")\\n plot_dataset(data)\\n plt.scatter(x[0], x[1], marker=marker_for_class[proposed_class], color='w', s=100)\\n \\n plt.figure()\\n plt.title(f\\\"Losses for label {proposed_class}\\\")\\n plt.plot(losses)\\n \\n plt.figure()\\n plt.title(f\\\"x loss for label {proposed_class}\\\")\\n plt.plot(x_losses)\\n \\n plt.figure()\\n plt.title(f\\\"x probs for label {proposed_class}\\\")\\n plt.plot(x_vals)\\n \\n model.cpu()\\n \\n if normalize:\\n results = np.array(results) / sum(results)\\n else:\\n results = np.array(results)\\n return results if not return_params else (results, new_model)\",\n \"def normalize_transform():\\n\\n # Default for PyTorch's pre-trained models\\n return transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\",\n \"def get_probs(self, a):\\n with torch.no_grad():\\n probabilities = (np.array(self.priorities) ** a) / sum(np.array(self.priorities) ** a)\\n return probabilities\",\n \"def model_probs(self, classifier=None):\\n if not classifier:\\n classifier = RandomForestClassifier(n_estimators=100, n_jobs=-1)\\n classifier.fit(self.X_train, self.y_train)\\n predictions = classifier.predict_proba(self.X)\\n return predictions\",\n \"def predictability(self):\\n temp = self.probs\\n for n in range(10):\\n temp = temp.dot(temp)\\n final = temp[0,:]\\n #Let's assume that all words have unique initial letters\\n probs = map(len, self.words)\\n probs = array(probs)\\n probs = (probs + self.probs.max(1)-1)/probs\\n return sum(final*probs)\",\n \"def normalized(self) -> 'NormalizedFXParam':\\r\\n ...\",\n \"def test_compute_unnormalized_scores(self):\\n # todo: implement this test!\\n pass\",\n \"def get_normalized_probabilities(self, begin_date):\\n probs_df = self.data_provider.get_probs_df(begin_date)\\n\\n if probs_df.empty:\\n raise OptimizationException(\\\"There are no investment clock predictions available\\\")\\n sum_row = probs_df.sum(axis=1)\\n norm_probs = probs_df.div(sum_row, axis=0)\\n return norm_probs\",\n \"def get_normalized_probs(\\n self,\\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\\n log_probs: bool,\\n sample: Optional[Dict[str, Tensor]] = None,\\n ):\\n\\n if hasattr(self, \\\"adaptive_softmax\\\") and self.adaptive_softmax is not None:\\n if sample is not None:\\n assert \\\"target\\\" in sample\\n target = sample[\\\"target\\\"]\\n else:\\n target = None\\n out = self.adaptive_softmax.get_log_prob(net_output[0], target=target)\\n return out.exp_() if not log_probs else out\\n\\n logits = net_output[0]\\n if log_probs:\\n return log_softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\\n else:\\n return softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\",\n \"def get_normalized_probs(\\n self,\\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\\n log_probs: bool,\\n sample: Optional[Dict[str, Tensor]],\\n ):\\n\\n if hasattr(self, \\\"adaptive_softmax\\\") and self.adaptive_softmax is not None:\\n if sample is not None:\\n assert \\\"target\\\" in sample\\n target = sample[\\\"target\\\"]\\n else:\\n target = None\\n out = self.adaptive_softmax.get_log_prob(net_output[0], target=target)\\n return out.exp_() if not log_probs else out\\n\\n logits = net_output[0]\\n if log_probs:\\n return utils.log_softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\\n else:\\n return utils.softmax(logits, dim=-1, onnx_trace=self.onnx_trace)\",\n \"def normalize(self, arr):\\r\\n\\r\\n\\t\\t#Set the cap for arr at self.value_max and self.value_max\\r\\n\\t\\t#this prevents outliers of breaking the previously predicted p_func\\r\\n\\t\\tarr_capped = arr * (arr <= self.value_max) + self.value_max * (arr > self.value_max)\\t#cap to value_max\\r\\n\\t\\tarr_capped = arr_capped * (arr_capped >= self.value_min) + self.value_min * (arr_capped < self.value_min)\\t#cap to value_min\\r\\n\\r\\n\\t\\t#Normalize array\\r\\n\\t\\tnorm_factor = self.get_norm_factor(arr_capped)\\r\\n\\t\\tnormalized = arr * norm_factor\\r\\n\\r\\n\\t\\treturn(normalized)\",\n \"def normalize(probabilities):\\n for person in probabilities:\\n\\n # normalize the \\\"gene\\\"\\n geneSum = probabilities[person][\\\"gene\\\"][0] + probabilities[person][\\\"gene\\\"][1] + probabilities[person][\\\"gene\\\"][2]\\n for i in range(3):\\n probabilities[person][\\\"gene\\\"][i] /= geneSum\\n\\n # normalize the \\\"trait\\\"\\n traitSum = probabilities[person][\\\"trait\\\"][True] + probabilities[person][\\\"trait\\\"][False]\\n probabilities[person][\\\"trait\\\"][True] /= traitSum\\n probabilities[person][\\\"trait\\\"][False] /= traitSum\",\n \"def u_probs(self):\\n log_u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\\n\\n return self._prob_inverse_transform(numpy.exp(log_u))\",\n \"def stdProbabilityNorm(self):\\n return 1./factorial(self.alpha-1)\",\n \"def _normalize(self, inp):\\n \\n return inp/inp.sum()\",\n \"def normalize_label(labels):\\n max_val = torch.max(labels)\\n min_val = torch.min(labels)\\n norm_labels = (labels - min_val)/(max_val - min_val)\\n return norm_labels\",\n \"def __get_net_probs(self):\\n return np.array([node.value for node in self.net]).reshape(5,5)\",\n \"def normalize(audio):\\n norm = audio/max(audio)\\n return norm\",\n \"def mixed_prob( means,stds,weights,validt):\",\n \"def edit_probs(result):\\n for i in range(TOP_E):\\n p = result.data[i][1]\\n p = round(p, 4)\\n # p_str = str(p)[1:]\\n result.data[i][1] = p\\n\\n return result\",\n \"def norm_experiment():\\n print(\\\"NORM_EXPERIMENT\\\")\\n\\n # set the name of the experiment\\n now = datetime.datetime.now()\\n experiment_id = str(now.day) + \\\"_\\\" + str(now.month) + \\\"_\\\" + str(now.hour) + \\\".\\\" + str(now.minute)\\n experiment_name = 'normalization_' + str(experiment_id)\\n\\n # define if you want to use preprocessed data from file\\n use_prep_data = False\\n if use_prep_data:\\n set_params(preproc_data_id='16_5_10.16.47')\\n else:\\n set_params(use_preproc_data=False)\\n\\n # define the changing parameter and its value\\n changing_param_name = 'NORMALIZE'\\n changing_param_value = [1, 0]\\n # , {0:4, 1:100}, {0:3, 1:100}, {0:2, 1:100}, {0:1, 1:100}] #[{0:1, 1:1}, {0:15, 1:85}]#\\n\\n # set constant parameters\\n set_params(epochs=20)\\n set_params(dropout=0.3)\\n set_params(use_word_emb=1)\\n\\n # save constant parameters to a new \\\"experiment_..\\\" file\\n save_constant_parameters(experiment_name, changing_param_name)\\n\\n # run experiment for every parameter value\\n for value in changing_param_value:\\n\\n # update the parameter value\\n set_params(normalize = value)\\n\\n # update the model_id for this new model\\n now = datetime.datetime.now()\\n new_model_id = str(now.day) + \\\"_\\\" + str(now.month) + \\\"_\\\" + str(now.hour) + \\\".\\\" + str(now.minute) + \\\".\\\" + str(now.second)\\n set_params(model_id = new_model_id)\\n\\n # evaluate the new model and save the results in the experiment file\\n oneExperiment = Process(target=run_experiment, args=(experiment_name, new_model_id, changing_param_name, value,))\\n oneExperiment.start()\\n oneExperiment.join()\",\n \"def predict_proba(self, inputs):\\n return self.model.predict_proba(inputs)\",\n \"def normalize_parameters(self):\\n self.entity_embeddings.weight.data = normalize(self.entity_embeddings.weight.data,\\n p=self.norm_type, dim=1)\",\n \"def model_normalize_(self, ref_point: 'ModelParameters', order=2):\\n for parameter in self.parameters:\\n parameter *= (ref_point.model_norm(order) / self.model_norm())\",\n \"def __normalize(input, type, a, b):\\n return cv2.normalize(input, None, a, b, type)\",\n \"def priorProbabilities():\\r\\n\\ttotal = 0.0\\r\\n\\tpos = 0.0\\r\\n\\tneg = 0.0\\r\\n\\r\\n\\t# Count the amount of positives and negatives in the training data\\r\\n\\tfor item in trainingData:\\r\\n\\t\\ttotal += 1\\r\\n\\t\\tif item[1] == '0':\\r\\n\\t\\t\\tpos +=1\\r\\n\\t\\tif item[1] == '1':\\r\\n\\t\\t\\tneg +=1\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\r\\n\\t# Return the positive and negative probabilities \\r\\n\\tposProb = float(pos / total * 100)\\r\\n\\tnegProb = float(neg / total * 100)\\r\\n\\r\\n\\t\\r\\n\\t\\r\\n\\treturn posProb, negProb\",\n \"def get_probs(self, states, actions):\\n # YOUR CODE HERE\\n \\n probs = np.ones(len(states))/2\\n return probs\",\n \"def calc_prob_local(self, *args):\\n return 0\",\n \"def norm(self):\",\n \"def predict_proba(X, classifier):\\n prob = np.dot(X, classifier['coef_'].T) + classifier['intercept_']\\n prob = prob.ravel() if prob.shape[1] == 1 else prob\\n prob *= -1\\n np.exp(prob, prob)\\n prob += 1\\n np.reciprocal(prob, prob)\\n if prob.ndim == 1:\\n return np.vstack([1 - prob, prob]).T\\n else:\\n # OvR normalization, like LibLinear's predict_probability\\n prob /= prob.sum(axis=1).reshape((prob.shape[0], -1))\\n return prob\",\n \"def probabilities(self):\\n raise NotImplementedError\",\n \"def predict_proba(self):\\n ...\",\n \"def set_uniform_probabilities(self, sentence_aligned_corpus):\\n ...\",\n \"def norm(self):\\n # TODO: implement\\n return\",\n \"def normalize(self, factor):\",\n \"def get_probs(self, *vars):\\n freqs = self.freq_counts([self.data.get_column_view(v)[0] for v in vars], [len(v.values) for v in vars])\\n k = np.prod([len(v.values) for v in vars])\\n return (freqs + self.alpha) / (np.sum(freqs) + self.alpha*k)\",\n \"def m_probs(self):\\n log_m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n\\n return self._prob_inverse_transform(numpy.exp(log_m))\",\n \"def set_proba(self):\\n self.__c_elem().log_normalise()\",\n \"def _compute_model_prob(self, per_list_logodds):\\n with tf.compat.v1.name_scope(name='compute_model_prob'):\\n return tf.stop_gradient(\\n tf.exp(-self._alpha *\\n (per_list_logodds -\\n tf.reduce_min(per_list_logodds, axis=2, keepdims=True))))\",\n \"def uniform_start_probs(self) -> np.ndarray:\\n return np.ones(self.n_states) / self.n_states\",\n \"def normalize(distrib):\\n if isinstance(distrib, dict):\\n total_prob = sum(distrib.values())\\n if total_prob <= 0.:\\n # TODO: check bug > is this a sufficient condition for the error cases?\\n # TODO: check bug > Is just returning distrib enough?\\n InferenceUtils.log.warning(\\\"all assignments in the distribution have a zero probability, cannot be normalised\\\")\\n return distrib\\n\\n for key, value in distrib.items():\\n distrib[key] = distrib[key] / total_prob\\n return distrib\",\n \"def _get_model_priors(self):\\n if self._alpha_model_priors:\\n return self._alpha_model_priors\\n # sample the variables from their corresponding distributions\\n params = self._get_prior_params()\\n self._alpha_model_priors = self._params2probs(params)\\n return self._alpha_model_priors\",\n \"def normalize_parameters(self):\\n self.entity_embeddings.weight.data = normalize(self.entity_embeddings.weight.data,\\n p=self.norm_type, dim=1)\\n self.normal_vectors.data = normalize(self.normal_vectors, p=2, dim=1)\",\n \"def normalize(x):\\r\\n return x/norm(x)\",\n \"def unnormalized_loss(self):\\n return 0.5 * la.norm(self.resids) ** 2\",\n \"def normalized(self):\\n return self / self.norm()\",\n \"def predict_proba(self):\\n if self.rank_prob is None:\\n raise ValueError('No results available. Did you already call predict(...)?')\\n\\n return np.array([sum(map(lambda x: x[1], result)) / len(result) for result in self.rank_prob])\",\n \"def predict_proba(self, x):\\n e = self.predict_evidence(x)\\n a = e + self.prior\\n return a / torch.sum(a, dim=-1, keepdim=True)\",\n \"def normalize_parameters(self):\\n self.entity_embeddings.weight.data = normalize(self.entity_embeddings.weight.data,\\n p=2, dim=1)\\n self.relation_embeddings.weight.data = normalize(self.relation_embeddings.weight.data,\\n p=2, dim=1)\\n self.ent_proj_vects.data = normalize(self.ent_proj_vects.data, p=2, dim=1)\\n self.rel_proj_vects.data = normalize(self.rel_proj_vects.data, p=2, dim=1)\",\n \"def log_u_probs(self):\\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\\n return self._prob_inverse_transform(u)\",\n \"def probs(self) -> List:\\n return self._probs\",\n \"def predict(probs):\\n # Your code here.\\n return np.argmax(probs, axis=1)\",\n \"def normalize_input(inputs: [float]) -> [float]:\",\n \"def imgNormalize(img): \\n constant = np.sum(sitk.GetArrayFromImage(img))*np.prod(img.GetSpacing())\\n return img/constant\",\n \"def normalize(vals):\\n min_val = torch.min(vals)\\n max_val = torch.max(vals)\\n return (vals - min_val) / (max_val - min_val)\",\n \"def normalization(seq):\\n\\t\\tnew_seq = [6.3578286171 * x for x in seq]\\n\\t\\treturn new_seq\",\n \"def get_normalize(self):\\n return self.normalize\",\n \"def normalize(p,L): \\r\\n Norm = []\\r\\n for k in L:\\r\\n x = k - p\\r\\n norm = x.dot(x)**0.5\\r\\n if norm != 0:\\r\\n Norm.append(x/norm)\\r\\n else:\\r\\n print('warning: attempt to normalize 0')\\r\\n \\r\\n return Norm\",\n \"def naive_bn(data, attributes):\\n bn = []\\n attr = attributes['attr'].tolist()\\n # each attribute is only dependent on the class node\\n i = 0\\n while (i < len(attr)-1):\\n row = [attr[i], attr[-1]]\\n bn.append(row)\\n i= i + 1\\n # frequency table \\n freq = counts_table(data, attributes)\\n # conditional probabilities and prior probabilities\\n cond_probs, prior0, prior1 = conditional_probability(data, attributes, freq)\\n\\n return bn, cond_probs, prior0, prior1\",\n \"def predict_probability_model(*args):\\n final_data = None\\n any_null = validate_none(args)\\n if any_null:\\n final_data = transform_fields(args[-3:])\\n final_data = list(args[0:5]) + final_data\\n predicted = test_model(final_data)\\n converts, styles = user_converts(predicted)\\n\\n return [f'{predicted} %', converts] + styles\",\n \"def normalize(inp):\\n\\n out = inp / np.linalg.norm(inp, axis=1, keepdims=True)\\n\\n return out\",\n \"def NormalizePhenotypeScore(score, max_score):\\n return float(score) / float(max_score) * 100\",\n \"def probs(self):\\n warnings.warn(\\n \\\"VqeResult.probs is obsoleted. \\\" + \\\"Use VqeResult.get_probs().\\\",\\n DeprecationWarning)\\n return self.get_probs()\",\n \"def MakePredictiveDist(self):\\n raw_pmf = self.exam.MakeRawScoreDist(self)\\n return raw_pmf\",\n \"def normalize(sequence):\\n return [_norm(s) for s in sequence]\",\n \"def log_probs(self):\\n return np.array([m['log_probs'] for m in self.model_outs], dtype=np.float32)\",\n \"def get_raw_probability(self):\\n\\t\\tproba = RunOrder.BASE_SUCCESS_PROBABILITY\\n\\t\\tproba += (self.additional_percents + self.hidden_percents) * 10\\n\\t\\treturn proba\",\n \"def get_probs(self):\\n\\t\\tprobArray = []\\n\\t\\tfor combination in self.codepool:\\n\\t\\t\\tif self.feasible(combination):\\n\\t\\t\\t\\tprobArray.append(self.get_probability(combination))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprobArray.append(0)\\n\\t\\tprobArray = np.array(probArray) / np.sum(probArray)\\n\\t\\treturn probArray\",\n \"def prior(mu):\\n p = np.ones(len(mu))/(mu.max()-mu.min())\\n return p\",\n \"def _compute_input_normalization(*amps):\\n if len(amps) < 2:\\n raise ValueError('At least 2 amplitudes must be provided.')\\n n_bosons = len(amps)\\n left_range = range(n_bosons)\\n right_ranges = list(itertools.permutations(left_range))\\n total = 0.\\n for right_range in right_ranges:\\n i_prod = 1.\\n for idx1, idx2 in zip(left_range, right_range):\\n # if `idx1` and `idx2` are equal the contribution is given\\n # by the inner product of an amplitude with itself. Given\\n # that we are assuming the amplitudes to be normalized,\\n # the result is always 1 and we can just skip it\\n if idx1 == idx2:\\n pass\\n # otherwise we update the partial product computing the\\n # inner product of the two relevant amplitudes (states)\\n i_prod *= np.vdot(amps[idx1], amps[idx2])\\n total += i_prod\\n return np.sqrt(total)\",\n \"def stdProbabilityNorm(self):\\n B = factorial(self.alpha-1)*factorial(self.beta-1)/factorial(self.alpha+self.beta-1)\\n norm = 1.0/(2**(self.alpha+self.beta-1)*B)\\n return norm\",\n \"def raw_unigram_probability(self, unigram):\\n result = 0.0\\n result = self.unigramcounts[unigram]/self.total\\n\\n #hint: recomputing the denominator every time the method is called\\n # can be slow! You might want to compute the total number of words once, \\n # store in the TrigramModel instance, and then re-use it. \\n\\n\\n return result\",\n \"def __calculateNormalizedScores(self):\\n year_scores = {0 : []}\\n for venue in self.venue_scores:\\n v_scores = []\\n for year in self.venue_scores[venue]:\\n v_scores.append(self.venue_scores[venue][year])\\n if year not in year_scores:\\n year_scores[year] = []\\n year_scores[year].append(self.venue_scores[venue][year])\\n x_year = np.average(np.array(v_scores))\\n self.venue_scores[venue][0] = x_year\\n year_scores[0].append(x_year)\\n \\n ##for standardization\\n #year_metrics = {x : (np.average(np.array(year_scores[x])), np.std(np.array(year_scores[x]))) for x in year_scores}\\n ##for normalization\\n year_metrics = {x: (max(year_scores[x]), min(year_scores[x])) for x in year_scores}\\n \\n #print year_metrics\\n \\n for venue in self.venue_scores:\\n self.normalized_scores[venue] = dict()\\n for year in self.venue_scores[venue]:\\n #self.standard_scores[venue][year] = round((self.venue_scores[venue][year] - year_metrics[year][0]) / year_metrics[year][1],5)\\n #self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1]) / (year_metrics[year][0] - year_metrics[year][1]) + eps\\n self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1] + self.epsilon) / (year_metrics[year][0] - year_metrics[year][1] + self.epsilon)\",\n \"def normalize(vec):\\n return vec / length(vec)\",\n \"def predict_for_items(self, norm=True):\\n pred = self.item_vectors.dot(self.item_vectors.T)\\n if norm:\\n norms = np.array([np.sqrt(np.diagonal(pred))])\\n pred = pred / norms / norms.T\\n return pred\",\n \"def _get_prob(self, a, b=1.0):\\n p = self.prior\\n return (p * a) / ((1-p)*b + p*a)\",\n \"def normalize_profile(ph):\\n return ph/np.abs(ph[1])\",\n \"def log_m_probs(self):\\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n return self._prob_inverse_transform(m)\",\n \"def normalize(attributions):\\n # keepdims for division broadcasting\\n total = np.abs(attributions).sum(axis=1, keepdims=True)\\n\\n return np.abs(attributions) / total\",\n \"def normalize(cls, raw_score):\\n return super().normalize(raw_score)\",\n \"def normalize(cls, raw_score):\\n return super().normalize(raw_score)\",\n \"def normalize(cls, raw_score):\\n return super().normalize(raw_score)\",\n \"def normalize(cls, raw_score):\\n return super().normalize(raw_score)\",\n \"def probability_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\\n logits = args.attribution_model.output2logits(args.forward_output)\\n target_ids = args.target_ids.reshape(logits.shape[0], 1)\\n logits = logits.softmax(dim=-1)\\n # Extracts the ith score from the softmax output over the vocabulary (dim -1 of the logits)\\n # where i is the value of the corresponding index in target_ids.\\n return logits.gather(-1, target_ids).squeeze(-1)\",\n \"def sentiment_score(text, loaded_model = loaded_model, vectorizer = tokenizer):\\n # tweet_tf_idf = vect_char.transform(text)\\n tweet_token = tokenizer.texts_to_sequences(text)\\n tweet_token = pad_sequences(tweet_token, maxlen = 40)\\n sentiment = loaded_model.predict_proba(tweet_token)\\n neg_prob = sentiment[0][0]\\n pos_prob = sentiment[0][1]\\n return neg_prob, pos_prob\",\n \"def normalize(scores, default_score):\\n if len(scores) > 0:\\n max_scores = max(scores)\\n min_scores = min(scores)\\n\\n if max_scores == min_scores:\\n return [default_score] * len(scores)\\n scores = [float((score - min_scores) / (max_scores - min_scores)) for score in scores]\\n return scores\\n else:\\n return [default_score]\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\\n nominals = unp.nominal_values(data)\\n min_y, max_y = np.min(nominals), np.max(nominals)\\n\\n return (data - min_y) / (max_y - min_y)\",\n \"def probability_of_default(model, prediction_features):\\n return model.predict_proba(prediction_features)[:, 1]\",\n \"def preloadPositivityClassifier():\\n Sentience.__DEF_PROB_THRESHOLD = getSentencePositivity(\\\"!@#$%^&*\\\")\",\n \"def naiveBayesMixture(train_set, train_labels, dev_set, bigram_lambda,unigram_smoothing_parameter, bigram_smoothing_parameter, pos_prior):\\n\\n # TODO: Write your code here\\n # return predicted labels of development set\\n\\n # counters for Training Phase\\n ham = Counter()\\n ham_bi = Counter()\\n spam = Counter()\\n spam_bi = Counter()\\n\\n for string, label in zip(train_set, train_labels):\\n for i in range(len(string)):\\n word = string[i]\\n if i != len(string)-1:\\n word_bi = string[i] + ' ' + string[i+1]\\n if label == 1:\\n ham_bi.update({word_bi:1})\\n else:\\n spam_bi.update({word_bi:1})\\n if label == 1:\\n ham.update({word:1})\\n else:\\n spam.update({word:1})\\n\\n ham_len = 0\\n for w in ham:\\n ham_len += ham[w]\\n spam_len = 0\\n for w in spam:\\n spam_len += spam[w]\\n \\n hambi_len = 0\\n for w in ham_bi:\\n hambi_len += ham_bi[w]\\n spambi_len = 0\\n for w in spam_bi:\\n spambi_len += spam_bi[w]\\n\\n # labels for Development Phase\\n dev_labels = []\\n # dicts for P(word|ham) and P(word|spam)\\n p_ham = {}\\n p_spam = {}\\n p_hambi = {}\\n p_spambi = {}\\n\\n # develop likelihoods based on dev_set\\n for word in ham:\\n numerator = ham[word] + unigram_smoothing_parameter\\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\\n p_ham[word] = numerator / denominator\\n for word in spam:\\n numerator = spam[word] + unigram_smoothing_parameter\\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\\n p_spam[word] = numerator / denominator\\n\\n for word_bi in ham_bi:\\n numerator = ham_bi[word_bi] + bigram_smoothing_parameter\\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\\n p_hambi[word_bi] = numerator / denominator\\n for word_bi in spam_bi:\\n numerator = spam_bi[word_bi] + bigram_smoothing_parameter\\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\\n p_spambi[word_bi] = numerator / denominator\\n \\n numerator = unigram_smoothing_parameter\\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\\n p_ham_zero = numerator / denominator\\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\\n p_spam_zero = numerator / denominator\\n\\n numerator = bigram_smoothing_parameter\\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\\n p_hambi_zero = numerator / denominator\\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\\n p_spambi_zero = numerator / denominator\\n\\n for string in dev_set:\\n p_words_ham = math.log(pos_prior)\\n p_words_spam = math.log(1 - pos_prior)\\n\\n p_words_hambi = math.log(pos_prior)\\n p_words_spambi = math.log(1 - pos_prior)\\n \\n for i in range(len(string)):\\n word = string[i]\\n if word in p_ham:\\n p_words_ham += math.log(p_ham[word])\\n else:\\n p_words_ham += math.log(p_ham_zero)\\n if word in p_spam:\\n p_words_spam += math.log(p_spam[word])\\n else:\\n p_words_spam += math.log(p_spam_zero)\\n\\n if i != len(string)-1:\\n word_bi = string[i] + ' ' + string[i+1]\\n if word_bi in p_hambi:\\n p_words_hambi += math.log(p_hambi[word_bi])\\n else:\\n p_words_hambi += math.log(p_hambi_zero)\\n if word_bi in p_spambi:\\n p_words_spambi += math.log(p_spambi[word_bi])\\n else:\\n p_words_spambi += math.log(p_spambi_zero)\\n\\n p_ham_mix = p_words_ham*(1-bigram_lambda) + p_words_hambi*bigram_lambda\\n p_spam_mix = p_words_spam*(1-bigram_lambda) + p_words_spambi*bigram_lambda\\n\\n dev_labels.append(p_ham_mix >= p_spam_mix)\\n\\n return dev_labels\",\n \"def normalized_quantile_loss(actuals: torch.Tensor, predictions: torch.Tensor, quantiles: List[float] = None) -> torch.Tensor:\\n normalizer = torch.sum(abs(actuals))\\n if quantiles == None:\\n QL = QuantileLoss(quantiles=[0.1, 0.5, 0.9])\\n else:\\n QL = QuantileLoss(quantiles=quantiles)\\n\\n q_loss = QL.loss(y_pred = predictions, target = actuals)\\n reduced_q_loss = torch.sum(q_loss.reshape(-1, q_loss.shape[-1]), 0)\\n normalized_loss = 2 * reduced_q_loss / normalizer\\n return normalized_loss\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.660994","0.6277411","0.6277411","0.615602","0.59609705","0.5934441","0.5852608","0.58386904","0.5791599","0.5754615","0.5637674","0.5621181","0.5581037","0.5580047","0.5567485","0.55672115","0.5557296","0.5536824","0.55352044","0.5490201","0.5468736","0.5440069","0.54328465","0.5425386","0.540667","0.53967506","0.5363745","0.5357746","0.5314643","0.52471966","0.5245895","0.5231121","0.5221638","0.5212513","0.521188","0.5208386","0.52078575","0.51962113","0.51905245","0.51883507","0.51872474","0.5182678","0.5177635","0.5174574","0.517288","0.5172639","0.5171083","0.51693845","0.51673496","0.5151628","0.5133043","0.51311845","0.51261914","0.51154816","0.51111066","0.510546","0.5103042","0.51024765","0.50997436","0.5094149","0.50723565","0.5070475","0.50622344","0.5061929","0.5056917","0.50533295","0.5045938","0.5045182","0.5043446","0.5016463","0.50153536","0.501449","0.5007101","0.50038266","0.50030375","0.50002575","0.49972573","0.4990872","0.49843735","0.49831507","0.49768373","0.4974745","0.49679524","0.49648207","0.49568805","0.49558678","0.495215","0.49515367","0.49405566","0.49405566","0.49405566","0.49405566","0.49397865","0.49372655","0.49335924","0.49299634","0.49249274","0.49229568","0.49190617","0.4913589"],"string":"[\n \"0.660994\",\n \"0.6277411\",\n \"0.6277411\",\n \"0.615602\",\n \"0.59609705\",\n \"0.5934441\",\n \"0.5852608\",\n \"0.58386904\",\n \"0.5791599\",\n \"0.5754615\",\n \"0.5637674\",\n \"0.5621181\",\n \"0.5581037\",\n \"0.5580047\",\n \"0.5567485\",\n \"0.55672115\",\n \"0.5557296\",\n \"0.5536824\",\n \"0.55352044\",\n \"0.5490201\",\n \"0.5468736\",\n \"0.5440069\",\n \"0.54328465\",\n \"0.5425386\",\n \"0.540667\",\n \"0.53967506\",\n \"0.5363745\",\n \"0.5357746\",\n \"0.5314643\",\n \"0.52471966\",\n \"0.5245895\",\n \"0.5231121\",\n \"0.5221638\",\n \"0.5212513\",\n \"0.521188\",\n \"0.5208386\",\n \"0.52078575\",\n \"0.51962113\",\n \"0.51905245\",\n \"0.51883507\",\n \"0.51872474\",\n \"0.5182678\",\n \"0.5177635\",\n \"0.5174574\",\n \"0.517288\",\n \"0.5172639\",\n \"0.5171083\",\n \"0.51693845\",\n \"0.51673496\",\n \"0.5151628\",\n \"0.5133043\",\n \"0.51311845\",\n \"0.51261914\",\n \"0.51154816\",\n \"0.51111066\",\n \"0.510546\",\n \"0.5103042\",\n \"0.51024765\",\n \"0.50997436\",\n \"0.5094149\",\n \"0.50723565\",\n \"0.5070475\",\n \"0.50622344\",\n \"0.5061929\",\n \"0.5056917\",\n \"0.50533295\",\n \"0.5045938\",\n \"0.5045182\",\n \"0.5043446\",\n \"0.5016463\",\n \"0.50153536\",\n \"0.501449\",\n \"0.5007101\",\n \"0.50038266\",\n \"0.50030375\",\n \"0.50002575\",\n \"0.49972573\",\n \"0.4990872\",\n \"0.49843735\",\n \"0.49831507\",\n \"0.49768373\",\n \"0.4974745\",\n \"0.49679524\",\n \"0.49648207\",\n \"0.49568805\",\n \"0.49558678\",\n \"0.495215\",\n \"0.49515367\",\n \"0.49405566\",\n \"0.49405566\",\n \"0.49405566\",\n \"0.49405566\",\n \"0.49397865\",\n \"0.49372655\",\n \"0.49335924\",\n \"0.49299634\",\n \"0.49249274\",\n \"0.49229568\",\n \"0.49190617\",\n \"0.4913589\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60832953"},"document_rank":{"kind":"string","value":"4"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":239,"numItemsPerPage":100,"numTotalItems":95772,"offset":23900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNjc1Mzc2ODJkMmE2Mjg0NzVhMWJmZmNkIl0sImlhdCI6MTc5MDk4NTM3MCwianRpIjoiNDNhZWEyMDktMWVjZC00ZDNiLThiNTItY2Q0MGNhNDMyNDBkIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3OTA5ODg5NzAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.cdnsugj_i8wt6cTR8EhE0od30K85NZUgAObhNXdkPyXQDvwfGC1YJ1DBVJX8vvMLm8bUDr6QPwZTbotQB31RCA","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 |
|---|---|---|---|---|---|---|
Test trydo testing function example with break to normal exit | def test_trydo_break():
assert inspect.isgeneratorfunction(tryDo)
assert hasattr(tryDo, "tock")
assert hasattr(tryDo, "opts")
tymist = tyming.Tymist(tock=0.125)
assert tymist.tyme == 0.0
states = []
do = tryDo(tymth=tymist.tymen(), states=states, tock=0.25)
assert inspect.isgenerator(d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_run_loop_success(self):\n found = False\n pyint = Interpreter(limit=15)\n try:\n pyint.run(code=BF_CODE_LOOP_TWICE)\n except SystemExit: \n found = True\n self.assertFalse(found)",
"def test_retry_run(self):\n pass",
"def test_main(mock_t... | [
"0.63869816",
"0.63265485",
"0.63147306",
"0.62900674",
"0.6242783",
"0.61911696",
"0.6141206",
"0.6111745",
"0.60973704",
"0.59276676",
"0.58884645",
"0.5870281",
"0.58558637",
"0.5848308",
"0.5836646",
"0.58318436",
"0.5809373",
"0.5804813",
"0.5803023",
"0.5759391",
"0.575... | 0.6423723 | 0 |
Test trydo testing function example with close to force exit | def test_trydo_close():
tymist = tyming.Tymist(tock=0.125)
assert tymist.tyme == 0.0
states = []
do = tryDo(tymth=tymist.tymen(), states=states, tock=0.25)
assert inspect.isgenerator(do)
result = do.send(None)
assert result == 0
assert states == [State(tyme=0.0, context='enter', feed='D... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_terminate_run(self):\n pass",
"def test_close():\n while True:\n yield",
"def test_main(mock_timesleep,mock_network,mock_machine_pin):\n with pytest.raises(InterruptedError):\n AppSwitch.main()",
"def test_trydoer_close():\n tymist = tyming.Tymist(tock=0.125)\n doer ... | [
"0.6395225",
"0.619183",
"0.6189198",
"0.6176477",
"0.6169383",
"0.60915303",
"0.5879608",
"0.5844186",
"0.58387417",
"0.58095753",
"0.5774369",
"0.57531786",
"0.5726396",
"0.5708866",
"0.5701388",
"0.56967646",
"0.56804425",
"0.5680095",
"0.5647397",
"0.56312543",
"0.5620959... | 0.66664875 | 0 |
Test trydo testing function example with throw to force exit | def test_trydo_throw():
tymist = tyming.Tymist(tock=0.125)
assert tymist.tyme == 0.0
states = []
do = tryDo(tymth=tymist.tymen(), states=states, tock=0.25)
assert inspect.isgenerator(do)
result = do.send(None)
assert result == 0
assert states == [State(tyme=0.0, context='enter', feed='D... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_retry_run(self):\n pass",
"def test_trydo_break():\n assert inspect.isgeneratorfunction(tryDo)\n assert hasattr(tryDo, \"tock\")\n assert hasattr(tryDo, \"opts\")\n\n tymist = tyming.Tymist(tock=0.125)\n assert tymist.tyme == 0.0\n states = []\n\n do = tryDo(tymth=tymist.tyme... | [
"0.6433851",
"0.63803047",
"0.6284302",
"0.62418973",
"0.62312156",
"0.6203113",
"0.6190655",
"0.61465496",
"0.6130344",
"0.6108381",
"0.61045945",
"0.6095485",
"0.60884714",
"0.60814196",
"0.6035478",
"0.60191983",
"0.5978732",
"0.5939394",
"0.5919296",
"0.59102464",
"0.5907... | 0.6895369 | 0 |
Test ServerDoer ClientDoer classes | def test_server_client():
tock = 0.03125
ticks = 16
limit = ticks * tock
doist = doing.Doist(tock=tock, real=True, limit=limit)
assert doist.tyme == 0.0 # on next cycle
assert doist.tock == tock == 0.03125
assert doist.real == True
assert doist.limit == limit == 0.5
assert doist.do... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_for_client():",
"def test_create_client(self):\n pass",
"def test_get_client(self):\n pass",
"def test_delete_client(self):\n pass",
"def test_echo_server_client():\n tock = 0.03125\n ticks = 16\n limit = ticks * tock\n doist = doing.Doist(tock=tock, real=True, li... | [
"0.7513112",
"0.69929147",
"0.68744075",
"0.67281103",
"0.66821295",
"0.66807735",
"0.6652283",
"0.65622354",
"0.6543381",
"0.6526167",
"0.64628434",
"0.64329016",
"0.64329016",
"0.64329016",
"0.64329016",
"0.63859886",
"0.63597393",
"0.6336899",
"0.629655",
"0.6293273",
"0.6... | 0.7207533 | 1 |
Test EchoServerDoer ClientDoer classes | def test_echo_server_client():
tock = 0.03125
ticks = 16
limit = ticks * tock
doist = doing.Doist(tock=tock, real=True, limit=limit)
assert doist.tyme == 0.0 # on next cycle
assert doist.tock == tock == 0.03125
assert doist.real == True
assert doist.limit == limit == 0.5
assert doi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_for_client():",
"def test_server_client():\n tock = 0.03125\n ticks = 16\n limit = ticks * tock\n doist = doing.Doist(tock=tock, real=True, limit=limit)\n assert doist.tyme == 0.0 # on next cycle\n assert doist.tock == tock == 0.03125\n assert doist.real == True\n assert doist.... | [
"0.72575915",
"0.7249093",
"0.66610587",
"0.6635919",
"0.6635122",
"0.65471476",
"0.65235204",
"0.65007335",
"0.64428306",
"0.6440027",
"0.6419176",
"0.64183944",
"0.64183944",
"0.63425195",
"0.6333824",
"0.6316979",
"0.6309964",
"0.63007313",
"0.6276703",
"0.6199192",
"0.619... | 0.77605975 | 0 |
Test EchoConsoleDoer class Must run in WindIDE with Debug I/O configured as external console | def test_echo_console():
port = os.ctermid() # default to console
try: # check to see if running in external console
fd = os.open(port, os.O_NONBLOCK | os.O_RDWR | os.O_NOCTTY)
except OSError as ex:
# maybe complain here
return # not in external console
else:
os.close... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def console():\n start_console()",
"def get_console(self):\n\t\treturn None",
"def start_console(self):\n return",
"def test_console_driver(duthost):\n out = duthost.shell('ls /dev/ttyUSB*', module_ignore_errors=True)['stdout']\n ttys = set(out.split())\n pytest_assert(len(ttys) > 0, \"No ... | [
"0.6557113",
"0.6358973",
"0.6357349",
"0.6250034",
"0.62377596",
"0.62299806",
"0.6129152",
"0.612263",
"0.60406756",
"0.5996627",
"0.59710854",
"0.59572494",
"0.59531933",
"0.5940231",
"0.5929235",
"0.589979",
"0.5892514",
"0.5865835",
"0.58611655",
"0.5860659",
"0.585572",... | 0.74439275 | 0 |
Defines the null and alternative hypothesis. | def define_hypothesis(df, statistic, alternative, paired, alpha):
paired_text = f"the {statistic} difference" if paired else f"difference in {statistic}"
hypothesis = {
'two-sided_H0': f"{paired_text} equal to zero",
'two-sided_H1': f"{paired_text} not equal to zero",
'grea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_alternative(df, hypothesis, alternative='two-sided', alpha=0.05):\n df['H0'] = hypothesis[alternative + '_H0']\n df['H1'] = hypothesis[alternative + '_H1']\n formatted_alpha = round(alpha*100, 2)\n conclusion = 'There is no evidence' if df['p-val'][0] > alpha else 'There is evi... | [
"0.6455733",
"0.61753273",
"0.61616707",
"0.58870167",
"0.58759326",
"0.58596665",
"0.5715439",
"0.5703288",
"0.5663849",
"0.56625116",
"0.56293815",
"0.5621157",
"0.56145686",
"0.5562165",
"0.5533882",
"0.5483456",
"0.54680246",
"0.5450762",
"0.539382",
"0.5374309",
"0.53743... | 0.6396941 | 1 |
Tests the hypothesis using the pvalue and adds the conclusion to the results DataFrame. | def test_alternative(df, hypothesis, alternative='two-sided', alpha=0.05):
df['H0'] = hypothesis[alternative + '_H0']
df['H1'] = hypothesis[alternative + '_H1']
formatted_alpha = round(alpha*100, 2)
conclusion = 'There is no evidence' if df['p-val'][0] > alpha else 'There is evidence'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def define_hypothesis(df, statistic, alternative, paired, alpha):\n paired_text = f\"the {statistic} difference\" if paired else f\"difference in {statistic}\"\n hypothesis = {\n 'two-sided_H0': f\"{paired_text} equal to zero\",\n 'two-sided_H1': f\"{paired_text} not equal to zero\"... | [
"0.6139014",
"0.59191096",
"0.56186587",
"0.55141944",
"0.55031806",
"0.53873",
"0.53590375",
"0.5266749",
"0.5259233",
"0.5245075",
"0.5224029",
"0.52130735",
"0.520389",
"0.51930904",
"0.51885474",
"0.51866484",
"0.5186087",
"0.51756436",
"0.5168725",
"0.51264113",
"0.51248... | 0.640209 | 0 |
Perform correlation between two variables. | def correlation_test(sample1, sample2, method='pearson', alpha=0.05,
alternative='two-sided', show_graph=True, **kwargs):
text = 'relationship between the two variables'
hypothesis = {
'two-sided_H0': f"there is no {text}",
'two-sided_H1': f"there is a {text}... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def correlation(self, other):\n dates=self.get_dates(other.get_dates())\n #print(len(self.get_values(dates)))\n #print(len(other.get_values(dates)))\n #print(self.get_values(dates))\n r,p=stats.pearsonr(self.get_values(dates), other.get_values(dates))\n return r",
"def C... | [
"0.75207645",
"0.74861574",
"0.73077905",
"0.7302946",
"0.7222768",
"0.7151656",
"0.70080733",
"0.6993429",
"0.69753855",
"0.6928357",
"0.6922723",
"0.6893102",
"0.6852905",
"0.6846402",
"0.6845538",
"0.6818033",
"0.67677784",
"0.67537844",
"0.67537844",
"0.67466134",
"0.6725... | 0.0 | -1 |
Tests the null hypothesis that the data is normally distributed | def normality_test(sample, alpha=0.05, method='shapiro',
show_graph=True, **kwargs):
hypothesis = {
'two-sided_H0': f"the data is normally distributed",
'two-sided_H1': f"the data is not normally distributed"
}
sample = np.array(sample)
np_types... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_continuous():\n # assert the distribution of the samples is close to the distribution of the data\n # using kstest:\n # - uniform (assert p-value > 0.05)\n # - gaussian (assert p-value > 0.05)\n # - inversely correlated (assert correlation < 0)",
"def test_null_from_normal(self):\n ... | [
"0.71112454",
"0.7025147",
"0.66127676",
"0.6552619",
"0.64574045",
"0.6423659",
"0.6406812",
"0.6395794",
"0.63904554",
"0.63602495",
"0.63487864",
"0.6278788",
"0.6221371",
"0.6189141",
"0.61687404",
"0.61294156",
"0.61126345",
"0.61106765",
"0.6099031",
"0.6088916",
"0.606... | 0.0 | -1 |
Perform a Fisher exact test. | def fisher_exact_test(df, sample1, sample2, alpha=0.05,
show_graph=True, **kwargs):
hypothesis = {
'two-sided_H0': "the samples are independent",
'two-sided_H1': "the samples are dependent",
}
table = pd.crosstab(df[sample1], df[sample2])
sta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_fisher(self):\r\n self.assertFloatEqual(fisher([0.073, 0.086, 0.10, 0.080, 0.060]),\r\n 0.0045957946540917905)",
"def test_fisher_alpha(self):\n c = array([4,3,4,0,1,0,2])\n obs = fisher_alpha(c)\n self.assertFloatEqual(obs, 2.7823795367398798)",
... | [
"0.74760246",
"0.6522067",
"0.64530474",
"0.6412917",
"0.62115204",
"0.60252494",
"0.5753306",
"0.5741627",
"0.5709703",
"0.5694631",
"0.56128263",
"0.5588021",
"0.5570426",
"0.55371743",
"0.5528919",
"0.54683965",
"0.54555136",
"0.5447295",
"0.5433581",
"0.5433376",
"0.54263... | 0.61430454 | 5 |
Chisquared independence test between two categorical variables. | def chi2_test(df, sample1, sample2, correction=True, alpha=0.05,
show_graph=True, **kwargs):
hypothesis = {
'two-sided_H0': "the samples are independent",
'two-sided_H1': "the samples are dependent"
}
expected, observed, stats = pg.chi2_independence(df, samp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_categorical():\n # assert the distribution of the samples is close to the distribution of the data\n # using cstest:\n # - uniform (assert p-value > 0.05)\n # - very skewed / biased? (assert p-value > 0.05)\n # - inversely correlated (assert correlation < 0)",
"def chi_test_goodness... | [
"0.61919755",
"0.6090222",
"0.5977698",
"0.5950685",
"0.59144706",
"0.5875124",
"0.58437693",
"0.57276577",
"0.5675882",
"0.56587726",
"0.56542903",
"0.56377614",
"0.5602135",
"0.559903",
"0.5575093",
"0.5568508",
"0.55496687",
"0.5521763",
"0.5510721",
"0.54972994",
"0.54895... | 0.51980954 | 55 |
Ttest can be paired or not. The paired ttest compares the means of the same group or item under two separate scenarios. The unpaired ttest compares the means of two independent groups. | def t_test(sample1, sample2, paired=False, alpha=0.05,
alternative='two-sided', correction='auto', r=0.707,
show_graph=True, **kwargs):
confidence = 1 - alpha
df_result = pg.ttest(
sample1,
sample2,
paired=paired,
confidence=c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ttest_2samp(x1, x2, alpha=0.05, paired=False, is_bernoulli=False, two_sided=True, return_tuple=False):\n x = np.asarray(x1)\n y = np.asarray(x2)\n\n # Define test degrees of freedom\n if two_sided:\n quant_order = 1 - (alpha / 2)\n h0 = 'X1_bar = X2_bar'\n h1 = 'X1_bar != X2_ba... | [
"0.6858824",
"0.67689383",
"0.66971606",
"0.6666218",
"0.6638158",
"0.6576945",
"0.6485257",
"0.64660966",
"0.6455032",
"0.64471155",
"0.64399266",
"0.64118457",
"0.6377159",
"0.6345801",
"0.6295458",
"0.6133576",
"0.6128303",
"0.6061013",
"0.60073733",
"0.5988047",
"0.586850... | 0.6669023 | 3 |
Confidence interval for differences (nonGaussian unpaired data) | def non_param_unpaired_ci(sample1, sample2, alpha=0.05):
n1 = len(sample1)
n2 = len(sample2)
N = norm.ppf(1 - alpha/2)
diffs = sorted([i-j for i in sample1 for j in sample2])
k = np.math.ceil(n1*n2/2 - (N * (n1*n2*(n1+n2+1)/12)**0.5))
CI = (round(diffs[k-1], 3), round(dif... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_confidence_interval(data):\n a = 1.0 * np.array(data)\n m = np.mean(a)\n std = np.std(a)\n pm = 1.96 * (std / np.sqrt(len(a)))\n return m, pm",
"def confidence_intervals(data):\r\n\r\n x_bar = np.nanmean(data) # Mean value\r\n s = np.nanstd(data) # Standard deviation\r... | [
"0.7395203",
"0.7145817",
"0.6741393",
"0.66793495",
"0.6660753",
"0.6656944",
"0.663477",
"0.65957725",
"0.6511848",
"0.6493911",
"0.6453965",
"0.64177084",
"0.6402729",
"0.63797855",
"0.6348145",
"0.6324356",
"0.62575376",
"0.6243653",
"0.62149024",
"0.6190887",
"0.61880887... | 0.59291995 | 32 |
Confidence interval for differences between the two samples. | def non_param_paired_ci(sample1, sample2, alpha):
n = len(sample1)
N = norm.ppf(1 - alpha/2)
diff_sample = sorted(list(map(operator.sub, sample2, sample1)))
averages = sorted([(s1+s2)/2 for i, s1 in enumerate(diff_sample)
for _, s2 in enumerate(diff_sample[i:])]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def confidenceInterval(start,end,confidence):\n\n\tmean = 0.5*(end+start)\n\tstddev = getStdDev(0.5*(end-start), confidence)\n\n\treturn (mean,stddev)",
"def do_mean_cis_differ(mean1, ci1, mean2, ci2):\n\n assert ci1 >= 0.0 and ci2 >= 0.0, 'Found negative confidence interval from bootstrapping.'\n x1 = mea... | [
"0.69878685",
"0.69680375",
"0.6955768",
"0.6875255",
"0.6774121",
"0.64958274",
"0.6471887",
"0.6469817",
"0.6291839",
"0.6264346",
"0.61657953",
"0.6164545",
"0.6094606",
"0.60685885",
"0.60413724",
"0.60233855",
"0.5988977",
"0.5958142",
"0.5919842",
"0.5896381",
"0.586550... | 0.581309 | 22 |
DO NOT TOUCH THIS FUNCTION. IT IS USED FOR COMPUTER EVALUATION OF YOUR CODE | def main():
conf_matrix1 = one_vs_all()
conf_matrix2 = all_vs_all()
results = my_info() + '\t\t'
results += np.array_str(np.diagonal(conf_matrix1)) + '\t\t'
results += np.array_str(np.diagonal(conf_matrix2))
print results + '\t\t'
# sum = 0
#
# for i in range(len(conf_matrix1)):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exercise_b2_106():\r\n pass",
"def exercise_b2_113():\r\n pass",
"def exercise_b2_107():\r\n pass",
"def exo2():",
"def exercise_b2_53():\r\n pass",
"def exercise_b2_69():\r\n pass",
"def substantiate():",
"def cx():",
"def exercise_b2_70():\r\n pass",
"def exercise_b2_98():... | [
"0.6566857",
"0.6499232",
"0.6485341",
"0.64318156",
"0.6431804",
"0.63610214",
"0.6329877",
"0.6256674",
"0.6234512",
"0.6231",
"0.62212175",
"0.6176965",
"0.6172292",
"0.61367464",
"0.6136744",
"0.61277723",
"0.6112681",
"0.6068746",
"0.60585713",
"0.6025986",
"0.59825903",... | 0.0 | -1 |
Called from the definition file with the description of the state. Receives a dictionary and populates internal structures based on it. The | def AddState(self, **dic):
state = State()
state.name = dic['name']
state.external_name = dic['external']
state_transitions = []
for (condition, destination) in dic['transitions']:
transition = Transition(condition, state.name, destination)
state_transitions.append(transition)
se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_states(self, state_dict, start_state):\n self.state_dict = state_dict\n self.state_name = start_state\n self.state = self.state_dict[self.state_name]()",
"def load_state(self, dictionary):\n self.log_formatstr = dictionary['log_formatstr']\n self.backend_interval = di... | [
"0.6415245",
"0.62513024",
"0.62250906",
"0.62250906",
"0.62250906",
"0.6217904",
"0.61744905",
"0.6153479",
"0.6133525",
"0.61250806",
"0.6079985",
"0.6068479",
"0.60613006",
"0.60173726",
"0.6006548",
"0.6000775",
"0.5996518",
"0.5996518",
"0.59851617",
"0.5963311",
"0.5960... | 0.0 | -1 |
Called from the definition file with the definition of a condition. Receives the name of the condition and it's expression. | def AddCondition(self, name, expression):
self.conditions[name] = expression | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def condition(self) -> global___Expression:",
"def condition(self) -> global___Expression:",
"def eval_definition(exp, env):\n define_variable(definition_variable(exp), m_eval(definition_value(exp), env), env)\n return quote(\"ok\")",
"def condition(self, condition):\n\n self._condition = condit... | [
"0.60299903",
"0.60299903",
"0.58058965",
"0.57567054",
"0.5676619",
"0.5661788",
"0.5585156",
"0.55506593",
"0.5536422",
"0.54914516",
"0.54885614",
"0.5461103",
"0.54198915",
"0.54021317",
"0.53634095",
"0.5359292",
"0.53558147",
"0.5352741",
"0.5310563",
"0.53045696",
"0.5... | 0.73426414 | 0 |
Load the state machine definition file. In the definition file, which is based on the python syntax, the following variables and functions are defined. | def Load(self, filename):
self.sm['state'] = self.AddState
self.sm['condition'] = self.AddCondition
exec(open(filename).read(), self.sm)
self.name = self.sm['name']
if not self.name.isalnum():
raise Exception("State machine name must consist of only alphanumeric"
"charac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_state_machine_definitions(\n def_file: str) -> Tuple[str, YamlInputFile, MachineDefinition]:\n # Determine the data directory ad build the config file's absolute path\n model_definition_path = get_data_dir()\n model_definition_filename = os.path.sep.join(\n [model_definition_path, ... | [
"0.65411615",
"0.6423537",
"0.60361713",
"0.59719336",
"0.59658307",
"0.58369714",
"0.5749073",
"0.570999",
"0.5671639",
"0.5663093",
"0.56431085",
"0.56079596",
"0.558816",
"0.5572879",
"0.5572879",
"0.55678475",
"0.55635643",
"0.55422217",
"0.5507806",
"0.5505211",
"0.55027... | 0.76456934 | 0 |
Equivalent to AB or A\B in set theory. Difference/Relative Complement | def difference(a, b):
return list(filterfalse(lambda x: x in b, a)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reverse_difference():",
"def get_complement(seta):\n\n complement_set = set()\n\n for elem in seta:\n new_elem_tuple = (elem[0], float(D('1.0') - D(str(elem[1]))))\n complement_set.add(new_elem_tuple)\n\n return complement_set",
"def commutator(A, B):\n return A @ B - B @ A",
"d... | [
"0.6728144",
"0.61966085",
"0.61682",
"0.60336477",
"0.59859383",
"0.5885711",
"0.5876446",
"0.5855507",
"0.58093464",
"0.57327807",
"0.5728684",
"0.5707002",
"0.57048213",
"0.56865865",
"0.56851715",
"0.56820685",
"0.5665925",
"0.5650496",
"0.5631561",
"0.56121475",
"0.56004... | 0.0 | -1 |
Used to get next row of either list of dicts or cursor | def get_next_row(table, names):
if isinstance(table, list):
if not table:
return None, True
else:
return table.pop(0), False
else:
row = table.fetchone()
if row is None:
return None, True
else:
return dict(zip(names, row)),... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __next__(self) :\n\n data = self.cur.fetchone()\n if not data :\n raise StopIteration\n return RowReference(self.desc, data[1:])",
"def next(self, num_rows=10):\n\n start = self._cursor\n stop = start + num_rows\n self._cursor += num_rows\n return s... | [
"0.6931901",
"0.64631486",
"0.64456135",
"0.63371646",
"0.6249426",
"0.6236442",
"0.6208837",
"0.6197598",
"0.618017",
"0.6168919",
"0.61328393",
"0.6082178",
"0.60636836",
"0.6054832",
"0.6017265",
"0.59916645",
"0.59916645",
"0.598793",
"0.5943697",
"0.59400916",
"0.5934102... | 0.67075896 | 1 |
Used to group together all rows in a table | def grouped_sql(table, columns):
sql = \
" ( " + \
"SELECT " + ",".join(columns) + ", COUNT(*) " + \
"AS COUNT " + \
" FROM " + ",".join(table) + \
" GROUP BY " + ",".join(columns) + \
" ) "
return sql | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def group_by(self, columns):\n\n return self._get(\"group\", columns, Table)",
"def generate_table(self, rows):\n ...",
"def group(self, j, function=FIRST, key=lambda v: v):\n if not isinstance(function, (tuple, list)):\n function = [function] * self._m\n J = j\n #... | [
"0.6104078",
"0.59451896",
"0.59261405",
"0.59202516",
"0.5898231",
"0.58725226",
"0.5824926",
"0.5820556",
"0.581354",
"0.5757736",
"0.5685524",
"0.56686515",
"0.5659242",
"0.5645669",
"0.5645669",
"0.56298447",
"0.56032294",
"0.5570632",
"0.55481434",
"0.55481434",
"0.55449... | 0.5494387 | 23 |
Used to find all rows in one table but not in another, not treating rows as distinct. | def unsorted_not_distinct(table1, table2, subset=False):
only_in_table1 = []
if subset:
# When subset, a row in table1 is not subset,
# if its contains more instances of a row than table2
for row in table1:
count1 = table1.count(row)
count2 = table2.count(row)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setDifference(self, table2):\n results = set([])\n for rec in self.records:\n rec_tuple = tuple([v for (k, v) in rec.items()])\n results.add(rec_tuple)\n for rec in table2.records:\n rec_tuple = tuple([v for (k, v) in rec.items()])\n if rec_tuple... | [
"0.68144566",
"0.671206",
"0.65324634",
"0.649911",
"0.6377828",
"0.6274883",
"0.6272812",
"0.6096138",
"0.60055655",
"0.5998634",
"0.59853375",
"0.5975118",
"0.59444433",
"0.59095633",
"0.5894284",
"0.58582914",
"0.58507025",
"0.5822497",
"0.5753021",
"0.5674006",
"0.5666055... | 0.67386425 | 1 |
Used to find all rows in one table but not in another. | def tab_unsorted(table1, table2, where_conditions, dw_rep):
sql = \
" SELECT * " + \
" FROM " + table1 + \
" AS table1 " + \
" WHERE NOT EXISTS" \
" ( " + \
" SELECT NULL " + \
" FROM " + table2 + \
" AS table2 " + \
" WHERE " + " AND ".join(w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setDifference(self, table2):\n results = set([])\n for rec in self.records:\n rec_tuple = tuple([v for (k, v) in rec.items()])\n results.add(rec_tuple)\n for rec in table2.records:\n rec_tuple = tuple([v for (k, v) in rec.items()])\n if rec_tuple... | [
"0.6672395",
"0.6617561",
"0.65095437",
"0.6373357",
"0.6184577",
"0.6165197",
"0.59691566",
"0.5948662",
"0.5894413",
"0.58872354",
"0.5830431",
"0.58233774",
"0.5791073",
"0.5774153",
"0.5673653",
"0.56427497",
"0.5573534",
"0.5549403",
"0.55481064",
"0.55452496",
"0.552260... | 0.683357 | 0 |
Does a positional comparison of two sorted tables | def sorted_compare(actual, expected):
# Get names of attributes
names = [t[0] for t in actual.description]
result = True
actual_empty = False
expected_empty = False
# Run through both lists as long as we find no errors and no list is empty.
while result and not actual_empty and not expecte... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __cmp__(self, other_table):\n # __cmp__ functions return -1 if we are less than schema\n # 0 if we are the same as schema\n # 1 if we are greater than schema\n # If our 'compare' method returns anything there are differences\n ... | [
"0.6801732",
"0.65068626",
"0.6435971",
"0.64123297",
"0.6186599",
"0.617459",
"0.6155578",
"0.6145169",
"0.6141934",
"0.6133277",
"0.6119683",
"0.61114097",
"0.609584",
"0.6036873",
"0.60327053",
"0.60302013",
"0.60171545",
"0.60118",
"0.59924406",
"0.5973167",
"0.5945185",
... | 0.0 | -1 |
Does a subset comparison of two sorted tables | def subset_sorted_compare(actual, expected):
# Get names of attributes
names = [t[0] for t in actual.description]
e_row, expected_empty = get_next_row(expected, names)
if not expected_empty:
result = None not in e_row.values()
else:
result = False
actual_empty = False
# Ru... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare_tables(t1, t2):\n assert type(t1)==type(t2)\n assert isinstance(t1,(np.ndarray,DataTable,pd.DataFrame))\n assert np.shape(t1)==np.shape(t2)\n if isinstance(t1,DataTable):\n assert all([np.all(t1.c[i]==t2.c[i]) for i in range(np.shape(t1)[1])])\n else:\n assert np.all(t1==t2... | [
"0.6723325",
"0.6639622",
"0.6540761",
"0.64077485",
"0.63627774",
"0.6208932",
"0.6208834",
"0.6191564",
"0.6189009",
"0.61446047",
"0.6110602",
"0.60610974",
"0.5989919",
"0.59587985",
"0.59558547",
"0.58967036",
"0.5894383",
"0.58753526",
"0.5857242",
"0.5827912",
"0.58035... | 0.685202 | 0 |
Compares the two tables and sets their surpluses for reporting. | def run(self, dw_rep):
only_in_actual = []
only_in_expected = []
sort_result = False
# Gets the actual columns we want to compare on.
chosen_columns = self.setup_columns(dw_rep, self.actual_table,
self.column_names,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_if_two_tables(table_one, table_two):\n assert left_join(table_one, table_two) == [['fond', 'enamored', 'averse'], ['guide', 'usher', 'follow'], ['diligent', 'employed', 'idle'], ['wrath', 'anger', 'deligth']]",
"def __cmp__(self, other_table):\n # __cmp__ functions return -1 if we are less tha... | [
"0.6211615",
"0.61949384",
"0.6193802",
"0.6126203",
"0.5857758",
"0.5839341",
"0.5837315",
"0.5801258",
"0.57720935",
"0.5737858",
"0.5735085",
"0.5695702",
"0.5634066",
"0.5577839",
"0.5497134",
"0.54786825",
"0.54720753",
"0.5443053",
"0.542862",
"0.5407728",
"0.5389016",
... | 0.49782437 | 65 |
A view is the representation of a resource. During boottime applications can add resource representation as callables using this API. Since there can be more than one representation of a resource, there can be more than one viewcallable for the same requestURL. In which case the view callable had to be resolved based o... | def add_view( *args, **kwargs ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_view(self, request=None, args=None, kwargs=None, **initkwargs):\n view = self.view_class(**initkwargs)\n view.setup(request, *(args or ()), **(kwargs or {}))\n return view",
"def as_view(cls, *class_args, **class_kwargs):\n def view(*args, **kwargs):\n self = view.v... | [
"0.63902235",
"0.6374959",
"0.6324555",
"0.6310613",
"0.62657696",
"0.6252142",
"0.61539096",
"0.60092854",
"0.6006901",
"0.59187603",
"0.59163207",
"0.59148866",
"0.5865454",
"0.5859748",
"0.5833161",
"0.5810865",
"0.577921",
"0.5751791",
"0.5749036",
"0.57035476",
"0.569929... | 0.6325184 | 2 |
Resolve ``request`` to viewcallable. For a successful match, populate relevant attributes, like `matchdict` and `view`, in ``request`` plugin. A viewcallable can be a plain python callable that accepts request and context arguments or a plugin implementing | def route( request, c ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _wrapped_view(request, *args, **kwargs):\n return view_func(request, *args, **kwargs)",
"def as_view(cls, action_map=None, **initkwargs):\n\n # Needs to re-implement the method but contains all the things the parent does.\n if not action_map: # actions must not be empty\n ... | [
"0.6543802",
"0.62480587",
"0.6214749",
"0.62027234",
"0.6197727",
"0.6166379",
"0.61643225",
"0.60714966",
"0.6056894",
"0.59635854",
"0.59240335",
"0.58575875",
"0.5834903",
"0.5803857",
"0.5791674",
"0.5789351",
"0.57790864",
"0.56896657",
"0.56607234",
"0.565373",
"0.5647... | 0.5111074 | 59 |
Generate path, including query and fragment (aka anchor), for ``request`` using positional arguments ``args`` and keyword arguments ``kwargs``. Refer to corresponding router plugin for specific signature for positional and keyword arguments. Returns urlpath string. This does not include SCRIPT_NAME, netlocation and sch... | def urlpath( request, *args, **kwargs ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_url(self, **kwargs):\n\n return build(\n self._request.path,\n self._request.GET,\n self._meta.prefix,\n **kwargs )",
"def pathfor( request, *args, **kwargs ):",
"def url(self, request_path=\"\"):\n return f\"{self.scheme}://{self.host}/{request... | [
"0.64753556",
"0.628129",
"0.62777704",
"0.62373245",
"0.6221489",
"0.62195736",
"0.6203761",
"0.61327916",
"0.6034436",
"0.6002653",
"0.5988426",
"0.5972479",
"0.5961196",
"0.59514344",
"0.59143126",
"0.5896229",
"0.5896229",
"0.58924574",
"0.5859545",
"0.5827251",
"0.580974... | 0.68177366 | 0 |
Callback for asyncrhonous finish(). Means the response is sent and the request is forgotten. Chained call originating from | def onfinish( request ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cb_request_done(result):\n self._current_request = None\n return result",
"def done(self):\n ## All done with the request object\n self.closed = True\n self.d.callback('')",
"def deferred_response(response, request):\n request.write(simplejson.dumps(response))\... | [
"0.73311496",
"0.66925883",
"0.66114795",
"0.66111887",
"0.6592106",
"0.65328",
"0.6502333",
"0.64901215",
"0.645132",
"0.64137673",
"0.63908446",
"0.6291713",
"0.6274575",
"0.6261008",
"0.6200714",
"0.61751294",
"0.6143416",
"0.6133714",
"0.61082023",
"0.6104768",
"0.6095540... | 0.7034546 | 2 |
When the router finds that a resource (typically indicated by the requestURL) has multiple representations, where each representation is called a variant, it has to pick the best representation negotiated by the client. Negotiation is handled through attributes like mediatype, language, charset and contentencoding. ``r... | def negotiate( request, variants ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def content_negotiation(self, request, environ, mtype_list):\n alist = request.sys_query_options.get(core.SystemQueryOption.format,\n None)\n if alist is None:\n if \"HTTP_ACCEPT\" in environ:\n try:\n alist = m... | [
"0.6388638",
"0.58420646",
"0.572146",
"0.56802297",
"0.56731945",
"0.56254303",
"0.56223434",
"0.56139547",
"0.55455554",
"0.551041",
"0.5460923",
"0.54406977",
"0.5377689",
"0.5287527",
"0.52641153",
"0.5233765",
"0.5164498",
"0.51348597",
"0.5087331",
"0.50804424",
"0.5079... | 0.6252837 | 1 |
Resource object to gather necessary data before a request is handled by the view (and templates). Return updated | def __call__( request, c ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh(self):\n self.dto = self.res.get()\n log.debug(f\"Refreshed {self.url}\")",
"def prePresent(self, request):",
"def _update_from_rest_data(self) -> None:",
"def __init__(self):\n super(Resource, self).__init__()\n\n # ____building form class for resources validation____... | [
"0.61961716",
"0.6112339",
"0.6090412",
"0.6077346",
"0.60087204",
"0.5996591",
"0.5987353",
"0.58234686",
"0.5803258",
"0.57999533",
"0.57669985",
"0.57632554",
"0.57432127",
"0.57427675",
"0.5713234",
"0.57062846",
"0.57042134",
"0.57032424",
"0.56993175",
"0.5684876",
"0.5... | 0.0 | -1 |
Use HTTP `headers` dictionary, to parse cookie name/value pairs, along with its metainformation, into Cookie Morsels. Get the cookie string from ``headers`` like, | def parse_cookies( headers ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __extractCookies(self, cookieString):\n parts = cookieString.split(\"; \")\n \n data = {}\n \n for cookie in parts:\n keyValues = cookie.split(\"=\")\n data[keyValues[0]] = keyValues[1]\n \n return data\n #print resultHeadersKv\n... | [
"0.66611415",
"0.64269054",
"0.6329864",
"0.6290737",
"0.6235485",
"0.6235485",
"0.6199424",
"0.61779773",
"0.61479324",
"0.60945964",
"0.60757387",
"0.59653485",
"0.59545845",
"0.5939655",
"0.5897959",
"0.58464956",
"0.5736396",
"0.56966174",
"0.5693424",
"0.56601405",
"0.56... | 0.80582446 | 0 |
Update ``cookies`` dictionary with cookie ``name`` and its ``morsel``. Optional Keyword arguments, typically, contain ``domain``, ``expires_days``, ``expires``, ``path``, which are set on the Cookie.Morsel directly. ``cookies``, Dictionary like object mapping cookie name and its morsel. It is updated inplace and return... | def set_cookie( cookies, name, morsel, **kwargs ) : | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_cookie(\n self,\n name: str,\n value: str,\n *,\n expires: Optional[str] = None,\n domain: Optional[str] = None,\n max_age: Optional[Union[int, str]] = None,\n path: str = \"/\",\n secure: Optional[bool] = None,\n httponly: Optional[bool... | [
"0.6560919",
"0.6371054",
"0.61873186",
"0.59360474",
"0.5889485",
"0.58349055",
"0.5782738",
"0.57371664",
"0.5694596",
"0.56428206",
"0.5622598",
"0.55732596",
"0.557322",
"0.5484455",
"0.54833525",
"0.54718137",
"0.54183614",
"0.53668654",
"0.5339797",
"0.5316583",
"0.5278... | 0.7567295 | 0 |
Encode `name` and `value` string into bytestring using 'utf8' encoding settings, convert value into base64. Return signed value as | def create_signed_value( name, value ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode_signed_value( name, value ):",
"def create_signed_value(self, name, value):\n timestamp = str(int(time.time()))\n value = base64.b64encode(value)\n signature = self._cookie_signature(name, value, timestamp)\n value = \"|\".join([value, timestamp, signature])\n return... | [
"0.74074805",
"0.72518563",
"0.6848577",
"0.68351907",
"0.68086785",
"0.67794716",
"0.6740177",
"0.6641136",
"0.65297794",
"0.6510254",
"0.64581174",
"0.6431112",
"0.63822645",
"0.6331633",
"0.6327253",
"0.63222975",
"0.6310317",
"0.6296021",
"0.62504447",
"0.62287617",
"0.62... | 0.70378983 | 2 |
Reverse of `create_signed_value`. Returns orignal value string. | def decode_signed_value( name, value ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_signed_value( name, value ):",
"def create_signed_value(self, name, value):\n timestamp = str(int(time.time()))\n value = base64.b64encode(value)\n signature = self._cookie_signature(name, value, timestamp)\n value = \"|\".join([value, timestamp, signature])\n return... | [
"0.7920129",
"0.7463464",
"0.6136986",
"0.60241175",
"0.58482724",
"0.5676598",
"0.5675891",
"0.5605429",
"0.5586185",
"0.55268997",
"0.5525378",
"0.5519846",
"0.5481415",
"0.5449742",
"0.5444262",
"0.54402775",
"0.54240555",
"0.5422352",
"0.5415995",
"0.5411165",
"0.5401655"... | 0.65975523 | 2 |
Instance of plugin implementing this interface corresponds to a single HTTP request. Note that instantiating this class does not essentially mean the entire request is received. Only when | def __init__( httpconn, method, uri, uriparts, version, headers ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, request):\n response = self.get_request(request)\n return response",
"def __init__( request ):",
"def _request(self, *args, **kwargs):\n request = self._make_request(*args, **kwargs)\n\n return self._collect_request(request)",
"def req():\n return Request()",... | [
"0.6189991",
"0.60930073",
"0.6061302",
"0.59549767",
"0.59143215",
"0.5901719",
"0.5868419",
"0.5847523",
"0.58012015",
"0.579273",
"0.577959",
"0.57579935",
"0.5743879",
"0.57389355",
"0.57323503",
"0.57314944",
"0.57161",
"0.5702668",
"0.56985885",
"0.56957847",
"0.5638289... | 0.0 | -1 |
Returns True if this request supports HTTP/1.1 semantics | def supports_http_1_1(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_server_should_be_http_1_1(httpbin):\n resp = get_raw_http_response(httpbin.host, httpbin.port, \"/get\")\n assert resp.startswith(b\"HTTP/1.1\")",
"def is_supported(self) -> bool:\n\n # TODO logging ?\n # TODO ICMP error if ttl is zero\n return self._version == 4 and self._ihl... | [
"0.63006914",
"0.6202393",
"0.61148703",
"0.61043656",
"0.5947065",
"0.59074837",
"0.5852643",
"0.5731418",
"0.56117535",
"0.5606208",
"0.5559672",
"0.5547659",
"0.55382115",
"0.55035686",
"0.5499543",
"0.5495566",
"0.5454329",
"0.54527396",
"0.54498947",
"0.5448252",
"0.5395... | 0.80598897 | 0 |
Returns the client's SSL certificate, if any. To use client certificates, `cert_reqs` configuration value must be set to ssl.CERT_REQUIRED. The return value is a dictionary, see SSLSocket.getpeercert() in the standard library for more details. | def get_ssl_certificate(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def client_certificate_config(self) -> Optional[pulumi.Input['ClientCertificateConfigArgs']]:\n return pulumi.get(self, \"client_certificate_config\")",
"def client_certificate(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"client_certificate\")",
"def client_certificate(self) ... | [
"0.7112209",
"0.70620036",
"0.6646048",
"0.6646048",
"0.6526283",
"0.6438687",
"0.6353446",
"0.61203897",
"0.61203897",
"0.6104504",
"0.609127",
"0.609127",
"0.6029551",
"0.5963813",
"0.5963813",
"0.595275",
"0.5936866",
"0.5927882",
"0.59048986",
"0.58622354",
"0.58016706",
... | 0.606661 | 12 |
Gets the value of the cookie with the given ``name``, else return | def get_cookie( name, default=None ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cookie(self, name):\n return self.cookies.get(name)",
"def get_cookie(self, name, value=None):\n try:\n return cherrypy.request.cookie[name].value\n except KeyError:\n return value",
"def cookie(self, name, default=None):\r\n return self._get_cookies().... | [
"0.8593456",
"0.85346776",
"0.8050004",
"0.7930324",
"0.7896314",
"0.77555186",
"0.7635223",
"0.71214765",
"0.70636433",
"0.70636433",
"0.69677705",
"0.6951423",
"0.6725989",
"0.6701835",
"0.65948856",
"0.65907526",
"0.6511549",
"0.6478165",
"0.6344316",
"0.614494",
"0.599972... | 0.7946743 | 3 |
Returns a signed cookie if it validates, or None. Call to this | def get_secure_cookie( name, value=None ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cookie(self, provided_cookie, decrypt=True):\n\n if 'HTTP_COOKIE' in self.environ:\n grab_cookie = cookies.SimpleCookie(self.environ['HTTP_COOKIE'])\n \n if provided_cookie in grab_cookie:\n if decrypt:\n try:\n ... | [
"0.67511994",
"0.64220226",
"0.61643136",
"0.6157462",
"0.6149605",
"0.5972794",
"0.5919926",
"0.5899736",
"0.5893973",
"0.5885634",
"0.5859752",
"0.5823456",
"0.5812559",
"0.5812559",
"0.5784276",
"0.57393366",
"0.5726692",
"0.5698617",
"0.5693313",
"0.5668825",
"0.56523204"... | 0.6572365 | 1 |
Return True if this request is considered finished, which is, when | def has_finished(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finished(self):\n return self._state == FINISHED_STATE",
"def isFinish(self):\n return self.finish",
"def isFinished(self):\n return self.isTimedOut()",
"def done(self):\n return self._status != Future.STATUS_STARTED",
"def isFinished():",
"def isFinished():",
"def isFin... | [
"0.7893599",
"0.785629",
"0.7801624",
"0.7791034",
"0.77553874",
"0.77553874",
"0.77553874",
"0.7745339",
"0.7745339",
"0.7745339",
"0.7722582",
"0.7720691",
"0.7706907",
"0.76873726",
"0.7687296",
"0.76775944",
"0.7634663",
"0.76284164",
"0.7626273",
"0.75619394",
"0.7538805... | 0.7938837 | 0 |
Returns True if this request is received using `chunked` TransferEncoding. | def ischunked() : | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode_chunked(self):\r\n cl = 0\r\n data = StringIO.StringIO()\r\n while True:\r\n line = self.rfile.readline().strip().split(\";\", 1)\r\n chunk_size = int(line.pop(0), 16)\r\n if chunk_size <= 0:\r\n break\r\n cl += chunk_size\r... | [
"0.59374046",
"0.5720478",
"0.5649413",
"0.5643323",
"0.553375",
"0.55225235",
"0.5521607",
"0.54682434",
"0.5453274",
"0.53548074",
"0.5349224",
"0.52951217",
"0.5291799",
"0.52821094",
"0.52617615",
"0.5254956",
"0.52493757",
"0.5239688",
"0.5227221",
"0.5220763",
"0.521872... | 0.7465098 | 0 |
Callback for asyncrhonous finish(). Means the response is sent and | def onfinish(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finished(self, reply):\n pass",
"async def _response_handler(self):",
"def onfinish( request ):",
"def onfinish( request ):",
"def done(self):\n ## All done with the request object\n self.closed = True\n self.d.callback('')",
"def send_final_request(self):\n with op... | [
"0.72541773",
"0.71216404",
"0.6963055",
"0.6963055",
"0.69151807",
"0.6638319",
"0.651408",
"0.64735484",
"0.64627695",
"0.6455456",
"0.6441771",
"0.6427784",
"0.64124346",
"0.64103615",
"0.6390289",
"0.6389782",
"0.63700086",
"0.63700086",
"0.6349477",
"0.63451564",
"0.6336... | 0.6521918 | 6 |
Use request.webapp.urlfor() to generate the url. | def urlfor( name, **matchdict ) : | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Url(self) -> str:",
"def _make_url(self):\n ...",
"def url(self, request_path=\"\"):\n return f\"{self.scheme}://{self.host}/{request_path}\"",
"def url():\n ...",
"def url(self):\n ...",
"def build_url(app, request):\n return '%s%s' % (app.url_root, request.path[1:])",
"... | [
"0.7394846",
"0.7333615",
"0.73251283",
"0.7199692",
"0.71141917",
"0.7086298",
"0.7086298",
"0.7045094",
"0.6963181",
"0.6919876",
"0.6882282",
"0.6875919",
"0.687345",
"0.68391496",
"0.67906547",
"0.67739296",
"0.67739296",
"0.677302",
"0.6763877",
"0.67542046",
"0.67514396... | 0.0 | -1 |
Use request.webapp.pathfor() to generate the url. | def pathfor( name, **matchdict ) : | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def url_for(self, path):\n if self.in_canvas:\n return self.get_app_url(path[1:])\n else:\n return '%s%s' % (settings.SITE_URL, path)",
"def pathfor( request, *args, **kwargs ):",
"def build_url(app, request):\n return '%s%s' % (app.url_root, request.path[1:])",
"def bu... | [
"0.7584648",
"0.7503941",
"0.7469561",
"0.7469561",
"0.73424727",
"0.73424727",
"0.7232096",
"0.7122197",
"0.70774573",
"0.7048095",
"0.70177126",
"0.7001433",
"0.6987334",
"0.6956988",
"0.6916245",
"0.68278766",
"0.67932373",
"0.6748939",
"0.6688148",
"0.6613891",
"0.6579176... | 0.0 | -1 |
Generate url for a different webapplication identified by ``instkey``. Typically uses webapp.appurl(). ``instkey``, A tuple of ``(appsec, netpath, configini)`` indexes into platform's `webapps` attribute | def appurl( instkey, name, **matchdict ) : | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_url(app, request):\n return '%s%s' % (app.url_root, request.path[1:])",
"def build_url(app, request):\n return '%s%s' % (app.url_root, request.path[1:])",
"def api_url(self, url_key):\n dic = self.api_endpoints()\n return dic.get(url_key)",
"def url(self):\n if not self._... | [
"0.58576363",
"0.58576363",
"0.5623256",
"0.56221247",
"0.55988806",
"0.5585243",
"0.5538256",
"0.5424072",
"0.53234696",
"0.53213304",
"0.5307345",
"0.5305116",
"0.52884024",
"0.52879715",
"0.5249623",
"0.5244203",
"0.5239846",
"0.5239406",
"0.52258646",
"0.5224644",
"0.5202... | 0.72840726 | 0 |
Instantiate a response plugin for a corresponding ``request`` plugin. ``request``, | def __init__( request ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, request: Request, response: Response):\n self.request = request\n self.response = response",
"def __init__(self, request, legacy_plugin):\n self._request = request\n self._format = legacy_plugin\n\n source = (\n \"<bytes>\"\n if isinstan... | [
"0.62610316",
"0.5856815",
"0.57992893",
"0.5761121",
"0.5701808",
"0.5666514",
"0.56111526",
"0.5601704",
"0.5554978",
"0.5491152",
"0.5488582",
"0.54775864",
"0.54698384",
"0.54117626",
"0.53446656",
"0.5330777",
"0.5324699",
"0.5299904",
"0.5282381",
"0.527949",
"0.5272502... | 0.5541629 | 9 |
Set a response status code. By default it will be 200. | def set_status( code ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setResponseCode(code, message=None):",
"def setResponseCode(self, code, message=None):\n assert not self.written, \"Response code cannot be set after data has been written: %s.\" % \"@@@@\".join(self.written)\n self.responseCode = code\n self.responseMessage = message",
"def status_cod... | [
"0.80714124",
"0.7299864",
"0.7288931",
"0.7265546",
"0.7265546",
"0.72009724",
"0.7186744",
"0.7174475",
"0.7165363",
"0.7111467",
"0.70771134",
"0.70771134",
"0.7026749",
"0.69407403",
"0.6925514",
"0.6722728",
"0.6721266",
"0.6686304",
"0.668352",
"0.6621333",
"0.6604315",... | 0.78074044 | 1 |
Sets the given response header ``name`` and ``value``. If there is already a response header by `name` present, it will be overwritten. Returns the new value for header name as bytestring. ``name``, bytestring of header field name, in lower case. ``value``, any type, which can be converted to string. | def set_header( name, value ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_header(self, name, value):\n key = name.upper()\n if key not in _RESPONSE_HEADER_DICT:\n key = name\n self._headers[key] = _to_str(value)",
"def SetResponseHeader(self, name, value):\n assert name.islower()\n new_headers = []\n new_header_set = False\n for head... | [
"0.83574027",
"0.7889172",
"0.78625196",
"0.778234",
"0.73784775",
"0.70307523",
"0.6647856",
"0.6492542",
"0.6332594",
"0.626928",
"0.6144178",
"0.60879344",
"0.6050496",
"0.59921557",
"0.59893656",
"0.58568585",
"0.58544004",
"0.583133",
"0.5787934",
"0.57267344",
"0.570350... | 0.7097082 | 5 |
Similar to set_header() except that, if there is already a response header by ``name`` present, ``value`` will be appended to existing value using ',' seperator. Returns the new value for header name as bytestring. ``name``, bytestring of header field name, in lower case. ``value``, Any type which can be converted to s... | def add_header( name, value ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append_header(self, name, value):\n name = name.lower()\n if name in self._headers:\n value = self._headers[name] + ',' + value\n\n self._headers[name] = value",
"def set_header(self, name, value):\n key = name.upper()\n if key not in _RESPONSE_HEADER_DICT:\n ... | [
"0.7748382",
"0.73166865",
"0.7067415",
"0.7052879",
"0.6868",
"0.6779429",
"0.6656014",
"0.65562063",
"0.6298724",
"0.62592614",
"0.6212194",
"0.606606",
"0.59807533",
"0.59497535",
"0.58782494",
"0.57572806",
"0.5731",
"0.56437075",
"0.56160206",
"0.55419695",
"0.55385184",... | 0.6342504 | 8 |
Sets the given chunk trailing header, ``name`` and ``value``. If there is already a trailing header by ``name`` present, it will be overwritten. Returns the new value for header name as bytestring. ``name``, bytestring of header field name, in lower case. ``value``, any type, which can be converted to string. | def set_trailer( name, value ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_header(self, name: str, value: str) -> None:\n self.__headers[name.title()] = value # value.lower()",
"def set_header(self, name, value):\n\n # NOTE(kgriffs): normalize name by lowercasing it\n self._headers[name.lower()] = value",
"def set_header( self, name, value, **params ):\n... | [
"0.65418494",
"0.6522374",
"0.64762324",
"0.6441",
"0.6401729",
"0.6241801",
"0.6101218",
"0.60385674",
"0.57232356",
"0.56232774",
"0.5599765",
"0.55176854",
"0.5413307",
"0.536029",
"0.5203817",
"0.5202332",
"0.51658064",
"0.5163279",
"0.5163279",
"0.51523733",
"0.5068459",... | 0.5543814 | 11 |
Similar to set_trailer() except that, if there is already a trailing header by ``name`` present, ``value`` will be appended to existing value using ',' seperator. Returns the new value for header name as bytestring. ``name``, bytestring of header field name, in lower case. ``value``, any type, which can be converted to... | def add_trailer( name, value ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append_header(self, name, value):\n name = name.lower()\n if name in self._headers:\n value = self._headers[name] + ',' + value\n\n self._headers[name] = value",
"def set_header( self, name, value, **params ):\n self.remove_header( name )\n self[ name ] = params ... | [
"0.6929069",
"0.59107393",
"0.5822869",
"0.5768683",
"0.57525563",
"0.5595093",
"0.5461574",
"0.54522544",
"0.5451935",
"0.5260403",
"0.525307",
"0.5168981",
"0.5065813",
"0.5061805",
"0.5030817",
"0.502269",
"0.49991527",
"0.49479535",
"0.49398062",
"0.4846587",
"0.48425302"... | 0.58077794 | 3 |
Set cookie `name`/`value` with optional ``kwargs``. Keyword arguments typically contains, ``domain``, ``expires_days``, ``expires``, ``path``. Additional keyword arguments are set on the Cookie.Morsel directly. By calling this method cookies attribute will be updated inplace. See | def set_cookie( name, value, **kwargs ) : | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_cookie( cookies, name, morsel, **kwargs ) :",
"def set_cookie(\n self,\n name: str,\n value: str,\n *,\n expires: Optional[str] = None,\n domain: Optional[str] = None,\n max_age: Optional[Union[int, str]] = None,\n path: str = \"/\",\n secure... | [
"0.8420435",
"0.79221094",
"0.7444182",
"0.74370587",
"0.7345756",
"0.7201238",
"0.71946406",
"0.7171358",
"0.71276164",
"0.66001695",
"0.6599659",
"0.6423538",
"0.631609",
"0.6207204",
"0.61627495",
"0.6073698",
"0.5977196",
"0.5935828",
"0.5813138",
"0.58102167",
"0.5718615... | 0.8409126 | 1 |
Similar to set_cookie() method, additionally signs and timestamps a cookie value so it cannot be forged. Uses | def set_secure_cookie( name, value, **kwargs ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_cookie( name, value, **kwargs ) :",
"def set(self, name, value, timestamp=None, expires_days=30, **kwargs):\n \n timestamp = timestamp and timestamp or str(int(time.time()))\n value = base64.b64encode(value)\n args = (name, value, timestamp)\n signature = _generate_cook... | [
"0.74688053",
"0.7455388",
"0.72751254",
"0.72063357",
"0.70475024",
"0.6851211",
"0.6815025",
"0.68128604",
"0.66326326",
"0.6592273",
"0.6509545",
"0.6509545",
"0.64895",
"0.6470476",
"0.64571637",
"0.6434016",
"0.64097345",
"0.6322631",
"0.63069767",
"0.6275352",
"0.625296... | 0.7734208 | 0 |
Deletes all the cookies the user sent with this request. | def clear_all_cookies(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear_cookies(self):\n self.base_driver.delete_all_cookies()",
"def logout():\n _cookies = ['user', 'pass', 'hash']\n for cookie in _cookies:\n util.web.delete_cookie(cookie)",
"def clear_cookies(response):\n for cookie_name in list(flask.request.cookies.keys()):\n ... | [
"0.8314878",
"0.79060113",
"0.7764054",
"0.75879586",
"0.74467",
"0.73246366",
"0.72249746",
"0.7155583",
"0.7140678",
"0.7131695",
"0.7051185",
"0.69263476",
"0.6845432",
"0.6812562",
"0.6739007",
"0.670739",
"0.66826046",
"0.66742474",
"0.6650126",
"0.6621511",
"0.6612393",... | 0.81525165 | 1 |
Subscribe a ``callback`` function, to be called when this response is finished. | def set_finish_callback( callback ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_response(self, callback):\n\n self.log.info(\"Received callback for subscription %s\", self.service_id)\n self.log.info(callback)\n\n # handle callbacks\n self.handle_callbacks()",
"def subscribe(self, callback: Callable) -> None:\n self.callbacks.add(callback)",
"... | [
"0.7337261",
"0.72173417",
"0.6887395",
"0.6764623",
"0.6744843",
"0.6545311",
"0.65448177",
"0.65093887",
"0.65067255",
"0.64918005",
"0.6415015",
"0.6398242",
"0.6356268",
"0.6323706",
"0.62204206",
"0.6189996",
"0.61888844",
"0.6179687",
"0.61578566",
"0.61118984",
"0.6095... | 0.7379709 | 0 |
For chunkedencoding, returns a boolean, if True means the response has started and response headers are written. | def isstarted(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ischunked() :",
"def ischunked() :",
"def respond(self):\r\n response = self.wsgi_app(self.environ, self.start_response)\r\n try:\r\n for chunk in response:\r\n # \"The start_response callable must not actually transmit\r\n # the response headers. Inst... | [
"0.69279814",
"0.69279814",
"0.6627819",
"0.62915945",
"0.5882213",
"0.5791212",
"0.5773702",
"0.5644884",
"0.5639833",
"0.55898815",
"0.5584943",
"0.55602825",
"0.5550169",
"0.5530503",
"0.5523043",
"0.5508481",
"0.548411",
"0.5482309",
"0.54782695",
"0.54697645",
"0.5438700... | 0.0 | -1 |
Returns True if this response is transferred using `chunked` TransferEncoding. | def ischunked() : | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode_chunked(self):\r\n cl = 0\r\n data = StringIO.StringIO()\r\n while True:\r\n line = self.rfile.readline().strip().split(\";\", 1)\r\n chunk_size = int(line.pop(0), 16)\r\n if chunk_size <= 0:\r\n break\r\n cl += chunk_size\r... | [
"0.57229114",
"0.5549699",
"0.5535076",
"0.5498817",
"0.5495948",
"0.54413956",
"0.5428297",
"0.5392888",
"0.53799695",
"0.53299",
"0.53035134",
"0.5299927",
"0.5269785",
"0.525448",
"0.52073103",
"0.5202222",
"0.5174824",
"0.5155284",
"0.5124991",
"0.5083998",
"0.50101703",
... | 0.72753114 | 0 |
Writes the given chunk to the output buffer. To actually write the output to the network, use the flush() method below. ``data``, bytestring of data to buffer for writing to socket. | def write( data ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, data):\n\t\tself.outputbuffer.write(data)",
"def writeChunk(chunk):",
"def write(self, chunk):\r\n if not self.started_response:\r\n raise AssertionError(\"WSGI write called before start_response.\")\r\n \r\n if not self.sent_headers:\r\n self.sent_hea... | [
"0.6934015",
"0.6678234",
"0.6595058",
"0.6541228",
"0.64646363",
"0.6454819",
"0.63661104",
"0.63642645",
"0.63609827",
"0.63536644",
"0.63479036",
"0.6335002",
"0.62879336",
"0.6281979",
"0.6279511",
"0.6213749",
"0.6124661",
"0.61069936",
"0.6097744",
"0.6094423",
"0.60685... | 0.55196303 | 59 |
Flushes the responseheader (if not written already) to the socket connection. Then flushes the writebuffer to the socket connection. ``finishing``, If True, signifies that data written since the last flush() on this response instance is the last chunk. It will also flush the trailers at the end of the chunked response.... | def flush( finishing=False, callback=None ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, chunk, callback=None, read_until_delimiter=CRLF):\n if not self.stream.closed():\n if callback is None:\n callback = functools.partial(self.stream.read_until,\n utf8(read_until_delimiter),\n ... | [
"0.5697157",
"0.5237605",
"0.52154744",
"0.51464176",
"0.5056116",
"0.5045713",
"0.50180554",
"0.5014987",
"0.49502966",
"0.49502966",
"0.4899851",
"0.4892243",
"0.48771352",
"0.4832465",
"0.48308593",
"0.47830316",
"0.46727931",
"0.4668935",
"0.46423793",
"0.4630665",
"0.462... | 0.6894146 | 0 |
Sends the given HTTP error code to the browser. If `flush()` has already been called, it is not possible to send an error, so this method will simply terminate the response. If output has been written but not yet flushed, it will be discarded and replaced with the error page. It is the caller's responsibility to finish... | def httperror( status_code=500, message=b'' ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_error(self, code, message=None):\r\n\r\n headers = []\r\n headers.extend(self.server.global_headers)\r\n configuration = self.server.configuration\r\n docpath = self.server.docpath\r\n\r\n if not hasattr(self, 'headers'):\r\n self.headers = self.MessageClass(s... | [
"0.68092066",
"0.67834115",
"0.676444",
"0.6731622",
"0.6619136",
"0.6616003",
"0.6560771",
"0.6518003",
"0.6505182",
"0.6353635",
"0.6325605",
"0.6325605",
"0.62494993",
"0.6215743",
"0.61458296",
"0.61113197",
"0.608032",
"0.6079682",
"0.60642403",
"0.6045984",
"0.5998613",... | 0.5434301 | 48 |
Use the view configuration parameter 'IHTTPRenderer' to invoke the view plugin and apply IHTTPRenderer.render() method with ``request``, ``c``, ``args`` and ``kwargs``. | def render( *args, **kwargs ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render(request, *args, **kw):",
"def render_view(self, h, *args):\n return self.view(h)",
"def render(self, *html, **opt):\n context = self.context\n # add request, response to context implicitly.\n context['request'] = self.request\n context['response'] = self.response\n ... | [
"0.6854912",
"0.68063754",
"0.6663782",
"0.64228576",
"0.6422032",
"0.63216287",
"0.6234819",
"0.6158419",
"0.6141992",
"0.6087013",
"0.60797894",
"0.60797894",
"0.60797894",
"0.60797894",
"0.60797894",
"0.60605824",
"0.6056176",
"0.6002161",
"0.58739036",
"0.5868972",
"0.586... | 0.6417768 | 5 |
Return a generator, which, for every iteration will call the ``callback`` function with ``request`` and ``c`` arguments, which are preserved till the iteration is over. The call back should return a a tuple representing a chunk, ``(chunk_size, chunk_ext, chunk_data)`` this will formatted into a response chunk and sent ... | def chunk_generator( callback, request, c ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _request_generator(request, data_handler):\n # First, the request header.\n yield data_handler.request_to_bytes(request)\n\n # Then, for the body. The body can be bytes or an iterator, but that's it.\n # The iterator is the more general case, so let's transform the bytes into\n # an iterator via... | [
"0.62096155",
"0.61808133",
"0.6032896",
"0.5845108",
"0.575135",
"0.57170826",
"0.5671511",
"0.5627092",
"0.56268936",
"0.545666",
"0.54119474",
"0.54040426",
"0.5395256",
"0.53291893",
"0.53276765",
"0.5250885",
"0.5200447",
"0.5184646",
"0.51722205",
"0.51582944",
"0.51517... | 0.8492581 | 0 |
Instantiate plugin with `viewname` and `view` attributes. | def __init__( viewname, view ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_plugin(self, **kwargs):\n return self.plugin_class(**kwargs)",
"def initialize(self, view, request, *args, **kwargs):\n view.request = request\n view.args = args\n view.kwargs = kwargs\n return view",
"def setup_view(view, request=None, *args, **kwargs):\n view.... | [
"0.6548358",
"0.6006528",
"0.5945799",
"0.5894253",
"0.58324546",
"0.5823484",
"0.5800297",
"0.57579005",
"0.57316625",
"0.56788945",
"0.5655144",
"0.5637644",
"0.56267685",
"0.5609166",
"0.56016356",
"0.55474275",
"0.5512851",
"0.549349",
"0.5422086",
"0.5387782",
"0.535329"... | 0.6774538 | 0 |
In the absence of method specific attributes or if the resolver cannot find an instance attribute to apply the handler call back, the object will simply be called. ``request``, | def __call__( request, c ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, *args, **kwargs):\n\t\treturn self.handler()(self.request(kwargs))",
"def dispatch_request(self, *args, **kwargs):\n self.args = args\n self.kwargs = kwargs\n self.meth = request.method.lower()\n self.resource = current_app.blueprints.get(request.blueprint, None)\n\... | [
"0.7087493",
"0.68776214",
"0.67371464",
"0.66994345",
"0.66787934",
"0.6633027",
"0.66189176",
"0.66167516",
"0.6572445",
"0.650089",
"0.6358427",
"0.63378036",
"0.6337083",
"0.61910105",
"0.6168588",
"0.6121533",
"0.6113042",
"0.60976046",
"0.60976046",
"0.60976046",
"0.609... | 0.56281394 | 64 |
Optional callable attribute, if present will be called at the end of a request, after the response has been sent to the client. Note that this is not the same as close callback, which is called when the connection get closed. In this case the connection may or may not remain open. Refer to HTTP/1.1 spec. ``request``, | def onfinish( request ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def after_request_handle(self, func):\n self.after_request.append(func)\n return func",
"def after_request(self, f):\n self.after_request_funcs.append(f)\n return f",
"def after_request(self, f):\n self.after_request_handlers.append(f)\n return f",
"def after_request... | [
"0.6787434",
"0.66382897",
"0.65115815",
"0.65115815",
"0.649444",
"0.6303967",
"0.6162508",
"0.60495746",
"0.59780455",
"0.59377056",
"0.5925452",
"0.5879692",
"0.5879692",
"0.5879692",
"0.5879692",
"0.5879692",
"0.5879692",
"0.5879692",
"0.5879692",
"0.5879692",
"0.5879692"... | 0.5815968 | 23 |
Transform incoming message entity. request will be updated in place. Returns the transformed request data. ``request``, | def transform( request, data, finishing=False ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_RequestEntity_to_Request(request_entity):\n result = ResponseEntity()\n try:\n user = User.objects.get(username=request_entity.username)\n account = Account.objects.get(user=user)\n request = Request.objects.get(id=request_entity.request_id)\n request = copy_field_Requ... | [
"0.68833864",
"0.6783613",
"0.61958045",
"0.59059",
"0.58546364",
"0.5654744",
"0.5643135",
"0.56137216",
"0.55739105",
"0.55085295",
"0.5467546",
"0.54665387",
"0.54277307",
"0.5413112",
"0.5336769",
"0.53211945",
"0.5305077",
"0.53003657",
"0.52656054",
"0.5237695",
"0.5232... | 0.6248069 | 2 |
Transform outgoing message entity. ``request.response`` will be updated inplace. ``request``, | def transform( request, data, finishing=False ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_response(self, request, response):\n return response",
"def process_response(self, request, response):\n return response",
"def apply_response(self, request):\n assert request.response is not None\n response = request.response\n\n other_addr = self.get_other_addre... | [
"0.6281616",
"0.6281616",
"0.60982984",
"0.59114945",
"0.5736397",
"0.57255626",
"0.57255626",
"0.56755185",
"0.56169486",
"0.56157714",
"0.56044424",
"0.55499613",
"0.5543159",
"0.5468557",
"0.5437959",
"0.54259264",
"0.54259264",
"0.5392236",
"0.53907865",
"0.53888",
"0.538... | 0.6202194 | 2 |
Handle exception in the context of a HTTP request ``request``. (etype, value, tb) tuple is what is returned by sys.exc_info(). Return a web page, capable of live debuging. | def render( request, etype, value, tb ): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def error(self, request):\n if self.debug:\n import cgitb\n request.stdout.write('Content-Type: text/html\\r\\n\\r\\n' +\n cgitb.html(sys.exc_info()))\n else:\n errorpage = \"\"\"<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<ht... | [
"0.729787",
"0.67636645",
"0.6706574",
"0.66115505",
"0.63101536",
"0.63044995",
"0.6287227",
"0.62505925",
"0.62089163",
"0.6201368",
"0.6133693",
"0.6084619",
"0.6072575",
"0.60724205",
"0.6067019",
"0.5994295",
"0.59837675",
"0.5959512",
"0.5947055",
"0.589282",
"0.5879489... | 0.0 | -1 |
Endpoint for API requests given book isbn | def api(isbn):
# Ensure valid isbn-10 format provided
if len(isbn) != 10:
response = make_response(
jsonify("Please provide a valid ISBN-10"), 404)
response.headers['X-Error'] = "Please provide a valid ISBN-10"
return response
# Ensure requested book is in our database
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_book(isbn):\n isbn = Markup.escape(isbn)\n # check if book exist in database\n book_db = db.execute(\n \"SELECT * FROM books WHERE isbn LIKE :isbn\", {\"isbn\": isbn}\n ).fetchone()\n if book_db == None:\n return jsonify({\"error\": \"Invalid isbn or not in our database\"}), 40... | [
"0.7609882",
"0.74613976",
"0.74272406",
"0.7041582",
"0.68572766",
"0.67950946",
"0.67200625",
"0.6669115",
"0.6622111",
"0.6500195",
"0.6484592",
"0.64041054",
"0.6352689",
"0.63392377",
"0.62087476",
"0.61840034",
"0.61652505",
"0.6151179",
"0.61272323",
"0.6125678",
"0.61... | 0.77853644 | 0 |
Checks if requested username is available, returns JSON for clientside validation | def check():
username = request.args.get("user_name")
users = db.execute("SELECT * FROM users WHERE username = :username",
{"username": username}).fetchone()
if users is None:
return jsonify(True)
# Username is taken
return jsonify(False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_auth_validate_username():\n form = request.get_json(force=True)\n if \"username\" not in form:\n raise \"username is required\"\n return jsonify(\n userProvider.validate_username(\n form['username'].encode('utf8')\n )\n )",
"def checkusername():\n username =... | [
"0.80300266",
"0.80275035",
"0.8008234",
"0.79536533",
"0.7858642",
"0.78391534",
"0.77913445",
"0.7707726",
"0.76461107",
"0.75947815",
"0.75256544",
"0.7508425",
"0.7508425",
"0.7473909",
"0.7461905",
"0.74154615",
"0.7298308",
"0.72000253",
"0.71622324",
"0.7120716",
"0.70... | 0.7834931 | 6 |
Log user out, redirect to login | def logout():
session.clear()
return redirect("/") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logout():\n logout_user()\n return redirect(url_for(\".login\"))",
"def log_out():\n if 'name' in session:\n PLAN.logout_user(session['name'])\n session.pop('name', None)\n return redirect(url_for('log_in'))\n return redirect(url_for('log_in'))",
"def log_out(request):\n ... | [
"0.8145058",
"0.81327146",
"0.81260467",
"0.8065017",
"0.8052337",
"0.804527",
"0.80425847",
"0.80409956",
"0.7994507",
"0.7976262",
"0.7973859",
"0.7955485",
"0.7954831",
"0.7937982",
"0.7923433",
"0.7919691",
"0.7912803",
"0.7912725",
"0.79120165",
"0.7906303",
"0.7893122",... | 0.7610357 | 72 |
Validate and insert a book review | def review(book_id):
# User id from current session
user_id = session["user_id"]
# Form data
try:
rating = request.form.get('rating')
text = request.form.get('review-text')
except ValueError:
return error('Something went wrong with submission.', 400)
# Has user already ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def review():\r\n\r\n # Ensure isbn_number is submitted\r\n if not request.form.get(\"isbn_number\"):\r\n return apology(\"Invalid book\", 403)\r\n\r\n # Ensure review is submitted\r\n if not request.form.get(\"review\"):\r\n return apology(\"Text is not submitted\", 403)\r\n\r\n # Che... | [
"0.755315",
"0.6922114",
"0.6647781",
"0.65656424",
"0.6516517",
"0.64299977",
"0.627836",
"0.62092316",
"0.61660314",
"0.6143327",
"0.6090935",
"0.6080055",
"0.6045912",
"0.601442",
"0.60058033",
"0.59929514",
"0.598046",
"0.5961186",
"0.5902224",
"0.5900835",
"0.58474195",
... | 0.6872112 | 2 |
Renders books containing search query | def search():
try:
query = request.args.get("q").lower()
except AttributeError:
query = request.args.get("q")
# Adding browse functionality
browse = request.args.get("browse")
if browse is None:
# Select all rows with a column value that includes query
results = db.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_book():\n\n title = request.form.get(\"search\")\n books = book_search_results(GR_KEY, title)\n acct = get_current_account(session['acct'])\n search = True\n\n return render_template(\"index.html\", books=books, acct=acct, search=search)",
"def genSearch(request):\n \n assert isinst... | [
"0.81691885",
"0.7731352",
"0.76253176",
"0.7623431",
"0.7377619",
"0.7270599",
"0.724567",
"0.7031751",
"0.7023816",
"0.6892736",
"0.68789625",
"0.68769056",
"0.6811817",
"0.6783009",
"0.673157",
"0.67232525",
"0.66750485",
"0.6574503",
"0.6572845",
"0.65678513",
"0.6564493"... | 0.76361454 | 2 |
Query for the dates and temperature observations from the past 12 month from 20170823. Convert the query results to a Dictionary using date as the key and tobs as the value. Return the JSON representation of your dictionary | def Tobs_given_day(date):
results = session.query(Measurement.date,Measurement.tobs).\
filter(Measurement.date.between(One_yrs_ago,current_time)).\
filter(func.strftime("%Y-%m-%d",Measurement.date)==date).all()
results1=[results[i][1] for i in range(len(results))]
results={results[0][0]:results1}
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def temperature():\n #Query for the dates and temperature observations from a year from the last data point.\n\n last_temp= session.query(Measurement.date).order_by(Measurement.date.desc()).first()\n year_ago = last_temp - dt.timedelta(days=365)\n dates_and_temps = session.query(Measurement.date, Measu... | [
"0.7571382",
"0.7529138",
"0.7247193",
"0.7234718",
"0.7224095",
"0.72214264",
"0.71914005",
"0.71568054",
"0.7109943",
"0.706894",
"0.70655936",
"0.70236737",
"0.69873875",
"0.69621557",
"0.688697",
"0.6843332",
"0.6807451",
"0.6785279",
"0.67522395",
"0.67516905",
"0.671827... | 0.67368066 | 20 |
Return a JSON list of stations from the dataset | def stations():
results = session.query(Station.station,Station.name).all()
key=[results[i][0] for i in range(len(results))]
values=[results[i][1] for i in range(len(results))]
results=dict(zip(key,values))
print(f"Route /api/v1.0/stations is being visited")
return jsonify(results) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stationdata():\n # * Return a JSON list of stations from the dataset.\n # as this should be a list, I'm just grabbing the station name\n session = Session(engine)\n results = session.query(Station.name).all()\n session.close()\n\n stations = list(np.ravel(results))\n return jsonify(stati... | [
"0.88667464",
"0.8750095",
"0.87346923",
"0.84793985",
"0.84580904",
"0.84156215",
"0.83818555",
"0.83749765",
"0.8370349",
"0.8341339",
"0.8339504",
"0.8324717",
"0.83166987",
"0.83012885",
"0.82950824",
"0.82848144",
"0.82428265",
"0.8235163",
"0.82350534",
"0.82163185",
"0... | 0.7395977 | 33 |
Return a JSON list of Temperature Observations (tobs) for the previous year | def Tobs_past_year():
results = pd.DataFrame(session.query(Measurement.date,Measurement.tobs).\
filter(Measurement.date.between(One_yrs_ago,current_time)).all());
dates_of_last_year=list(results.sort_values(by='date')['date'].unique())
aa1=results.sort_values(by='date').groupby('date')
last_year_tob... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prior_year_temp():\n\n tobs_data = session.query(Measurements.tobs).all()\n return jsonify (tobs_data)",
"def tobsdata():\n # query for the dates and temperature observations from a year from the last data point.\n # * Return a JSON list of Temperature Observations (tobs) for the previous year.... | [
"0.81387526",
"0.7823207",
"0.7728094",
"0.76940525",
"0.76278925",
"0.7408873",
"0.73844993",
"0.7356113",
"0.73492384",
"0.7237004",
"0.7091124",
"0.70736796",
"0.7045663",
"0.7042862",
"0.6980327",
"0.6823793",
"0.6811926",
"0.6764229",
"0.66996694",
"0.6654598",
"0.656765... | 0.66404945 | 20 |
This Sigmoid function is used as a threshold function and mapping variables to between 0 and 1. | def sigmoid(inX):
if inX < 0:
return 1 - 1 / (1 + exp(inX))
else:
return 1 / (1 + exp(-inX)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hard_sigmoid(x):\n x = (0.2 * x) + 0.5\n x = F.threshold(-x, -1, -1)\n x = F.threshold(-x, 0, 0)\n return x",
"def sigmoid(x):\r\n return 1 / (1 + np.exp(-x))",
"def sigmoid(x):\r\n\r\n return 1 / (1 + np.exp(-x))",
"def sigmoid(x):\r\n #pred_x = (np.exp(x) - np.exp(-x)) / (np.exp(x)... | [
"0.8308929",
"0.82602733",
"0.8204889",
"0.81876445",
"0.81802076",
"0.81802076",
"0.81802076",
"0.81802076",
"0.81802076",
"0.81802076",
"0.8174843",
"0.8173835",
"0.81575894",
"0.8142804",
"0.8142804",
"0.8138578",
"0.81346345",
"0.8126009",
"0.8078116",
"0.8075239",
"0.806... | 0.7807045 | 44 |
This funtion is used to read the training data without any sampling. I tried the performance of this method and because of the negative result I do not use it in the final model. | def loadtrainData():
train_x = []
train_y = []
fileIn = open(PATH + 'traindata_Subtask4.txt')
for line in fileIn.readlines():
lineArr = line.strip().split()
train_x.append([float(lineArr[i]) for i in range(len(lineArr) - 1)])
train_y.append(int(lineArr[-1]))
return np.mat(tra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadtrainData_undersampling():\n train = []\n fileIn = open(PATH + 'traindata_Subtask4.txt')\n for line in fileIn.readlines():\n lineArr = line.strip().split()\n train.append([float(lineArr[i]) for i in range(len(lineArr))])\n\n pos = []\n neg = []\n for i in train:\n if ... | [
"0.70705503",
"0.685475",
"0.6755205",
"0.67205465",
"0.6707401",
"0.66407955",
"0.6628733",
"0.6578922",
"0.65660447",
"0.65466577",
"0.6519749",
"0.65176576",
"0.65046763",
"0.6502512",
"0.6450128",
"0.6430068",
"0.6429853",
"0.64113545",
"0.63941485",
"0.6373122",
"0.63673... | 0.6234176 | 36 |
This funtion is used to read the training data with over sampling. I tried the performance of this method and because of the negative result I do not use it in the final model. | def loadtrainData_oversampling():
pre_x = []
pre_y = []
fileIn = open(PATH + 'traindata_Subtask4.txt')
for line in fileIn.readlines():
lineArr = line.strip().split()
pre_x.append([float(lineArr[i]) for i in range(len(lineArr) - 1)])
pre_y.append(int(lineArr[-1]))
ros = Random... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadtrainData_undersampling():\n train = []\n fileIn = open(PATH + 'traindata_Subtask4.txt')\n for line in fileIn.readlines():\n lineArr = line.strip().split()\n train.append([float(lineArr[i]) for i in range(len(lineArr))])\n\n pos = []\n neg = []\n for i in train:\n if ... | [
"0.74855584",
"0.6844487",
"0.67235553",
"0.6635843",
"0.65714896",
"0.655013",
"0.65257406",
"0.65041095",
"0.64458853",
"0.6431045",
"0.6288388",
"0.6259542",
"0.6254891",
"0.6248755",
"0.62383735",
"0.62307274",
"0.62214607",
"0.6210643",
"0.6210329",
"0.62057644",
"0.6185... | 0.7424427 | 1 |
This funtion is used to read the training data with under sampling. In my training set, it including 153 positive samples and 3201 negative samples. By using this function, we can get all the positive samples and the same number of negative samples. | def loadtrainData_undersampling():
train = []
fileIn = open(PATH + 'traindata_Subtask4.txt')
for line in fileIn.readlines():
lineArr = line.strip().split()
train.append([float(lineArr[i]) for i in range(len(lineArr))])
pos = []
neg = []
for i in train:
if i[-1] == 1.0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadtrainData_oversampling():\n pre_x = []\n pre_y = []\n fileIn = open(PATH + 'traindata_Subtask4.txt')\n for line in fileIn.readlines():\n lineArr = line.strip().split()\n pre_x.append([float(lineArr[i]) for i in range(len(lineArr) - 1)])\n pre_y.append(int(lineArr[-1]))\n ... | [
"0.7016822",
"0.6664856",
"0.645917",
"0.64384604",
"0.64043915",
"0.63820744",
"0.6264231",
"0.625226",
"0.62346333",
"0.620052",
"0.6194809",
"0.6153491",
"0.61352617",
"0.61151683",
"0.6104559",
"0.6074965",
"0.6066834",
"0.6033847",
"0.60328984",
"0.6000171",
"0.5999229",... | 0.7961876 | 0 |
This funtion is used to read the top 10 claims in the dev set. | def loaddevData():
dev_x = []
dev_y = []
fileIn = open(PATH + 'devdata_Subtask4.txt')
for line in fileIn.readlines():
lineArr = line.strip().split()
dev_x.append([float(lineArr[i]) for i in range(len(lineArr) - 1)])
dev_y.append(int(lineArr[-1]))
return np.mat(dev_x), np.mat(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top_50():\r\n file_read = read_file()\r\n vacabulary_list = []\r\n for key in file_read:\r\n vacabulary_list.extend(file_read[key])\r\n top_50 = Counter(vacabulary_list).most_common(50)\r\n return (top_50)",
"def get_all_from_top_ten(title,users,max = 3):\n \"\"\" ten prolific users ... | [
"0.6306631",
"0.62041336",
"0.5929728",
"0.5903256",
"0.58970076",
"0.58926326",
"0.58617526",
"0.58617526",
"0.5834872",
"0.5782117",
"0.57493013",
"0.5723951",
"0.5718185",
"0.5674988",
"0.5643855",
"0.5617703",
"0.5616858",
"0.56101847",
"0.560401",
"0.55254406",
"0.551209... | 0.0 | -1 |
This function is the logistic regresion model with stochastic gradient descent. The input is the train_x, the label 'train_y' and the smooth method. I tried two different method in the model. The output is the weights that using for prediction. I also print the train loss and training time to analyse the effect of lear... | def trainLogRegres(train_x, train_y, opts):
startTime = time.time() # calculate training time
numSamples, numFeatures = np.shape(train_x)
alpha = opts['alpha']
maxIter = opts['maxIter']
weights = np.ones((numFeatures, 1))
for k in range(maxIter):
if opts['optimizeType'] == 'stocGradDe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.fl... | [
"0.70313853",
"0.69511914",
"0.6924913",
"0.6899533",
"0.6819347",
"0.6808069",
"0.6797615",
"0.6790879",
"0.67861557",
"0.6707913",
"0.66786504",
"0.6632093",
"0.65839654",
"0.65689814",
"0.65687764",
"0.6554728",
"0.65536284",
"0.6550399",
"0.6531903",
"0.6528379",
"0.65280... | 0.7041955 | 0 |
This function is used to predict the data by the logistice model. The input is the weights of logistics model, the dev_x and the label 'dev_y'. The output is the prediction result. | def testLogRegres(weights, dev_x, dev_y):
predict_y = []
numSamples, numFeatures = np.shape(dev_x)
for i in range(numSamples):
if sigmoid(dev_x[i, :] * weights) > 0.5:
label = 1
else:
label = 0
predict_y.append(label)
print('Congratulations, testing comple... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logistic_predict(weights, data):\n\n # TODO: Finish this function\n\n return y",
"def logistic_predict(self, x: np.array) -> np.array:\r\n if self.LogisticModel is None:\r\n print('Logistic Model not trained, please run logistic_fit first!')\r\n return None\r\n else:... | [
"0.69716686",
"0.67710924",
"0.6762844",
"0.6762844",
"0.6759554",
"0.6738379",
"0.67310774",
"0.67310774",
"0.67310774",
"0.6683879",
"0.66406286",
"0.658558",
"0.6546615",
"0.6540146",
"0.6515744",
"0.6444978",
"0.6444978",
"0.6444978",
"0.64326894",
"0.64309853",
"0.640947... | 0.72072643 | 0 |
This function is the same as the function for data preprocessing for querylikelihood unigram language model in Subtask3. | def Subtask4_pre_train_1(path):
n_dict = {}
files = os.listdir(path)
for i in files:
with open(os.path.join(path, i)) as fp:
lines = fp.readlines()
for line in lines:
text = eval(line)['text'] # extract data from the field of 'text'.
words = t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _preprocess(self):\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\n # self._get_frequent_features()\n # self._compactness_pruning()\n # self._redundancy_pruning()\n # self._ge... | [
"0.6739814",
"0.67387193",
"0.65274066",
"0.64582485",
"0.63389665",
"0.62616926",
"0.6239441",
"0.6239441",
"0.6239441",
"0.6239334",
"0.61333746",
"0.60674673",
"0.6042711",
"0.6042057",
"0.6011925",
"0.5964625",
"0.5963509",
"0.59263766",
"0.5914043",
"0.5899222",
"0.58957... | 0.0 | -1 |
This function is the same as the function for Laplace Smoothing querylikelihood unigram language model in Subtask3. | def Subtask4_pre_train_2_Laplace(number):
alpha = 0.5
train_data = load_dataset_json(PATH + 'data/train.jsonl', instance_num=number)
data = np.load(PATH + 'pre_train_1_Subtask4.npy', allow_pickle=True).item()
id_list = []
for d in train_data:
if d['label'] != 'NOT ENOUGH INFO':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def f(DATA_LINK, DATA_COLUMN_NAME, STOPWORD_CHOICE, STOPWORD_LINK, NGRAM_CHOICE,NGRAM_NUM, TestData,topic_number_user,fetchArray):\r\n data = pd.read_csv(DATA_LINK)\r\n df=data[DATA_COLUMN_NAME]\r\n ######################################################################\r\n if (STOPWORD_CHOICE):\r\n ... | [
"0.6209135",
"0.59615684",
"0.58722174",
"0.5867605",
"0.58490914",
"0.58312607",
"0.5767536",
"0.5758057",
"0.5740753",
"0.5735517",
"0.5712564",
"0.56631804",
"0.56478757",
"0.56061924",
"0.560608",
"0.5568739",
"0.55452985",
"0.553871",
"0.5532431",
"0.5531182",
"0.5530616... | 0.0 | -1 |
The output is a dictionary which the key is the document 'id' that appear in any of the claim's five similar documents and the value is 'lines' in wikipages. | def Subtask4_pre_train_3():
train_data = np.load(PATH + 'pre_train_2_Subtask4.npy', allow_pickle=True).item()
evidence = []
for d in train_data.items():
for i in range(5):
evidence.append(d[1][i])
files = os.listdir(PATH + 'data/wiki-pages/wiki-pages/')
documents = {}
for i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def documents(pmid_23982599, civic_aid6_document):\n return [pmid_23982599, civic_aid6_document]",
"def get_docs(claim: str, threshold: int = 50):\n with open(WIKI_IDS_PATH, \"rb\") as file:\n ids = pickle.load(file)\n docs = []\n compare_claim = _clean_text(claim)\n for doc_id in ids:\n ... | [
"0.63654256",
"0.60081065",
"0.5942371",
"0.5939073",
"0.58724165",
"0.5778564",
"0.5777038",
"0.56986195",
"0.5695576",
"0.56731904",
"0.5648699",
"0.56337243",
"0.5618151",
"0.5604732",
"0.55877995",
"0.5582474",
"0.55180943",
"0.54923135",
"0.54890287",
"0.5477085",
"0.546... | 0.0 | -1 |
The output is a list which the structure is [claim, evidence document, sentence_number]. | def Subtask4_pre_train_4():
evidence_data = load_dataset_json(PATH + 'data/train.jsonl', instance_num=200)
evi = []
for i in evidence_data:
for j in i['evidence']:
evi.append([i['claim'], j[0][2], j[0][3]])
evi_new = []
for e in evi:
if e not in evi_new:
evi_n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def documents(pmid_23982599, civic_aid6_document):\n return [pmid_23982599, civic_aid6_document]",
"def collect_sentences(self):\n sentences = []\n for document in self.documents:\n for sentence_token in document.sentences:\n sentences.append(sentence_token)\n re... | [
"0.6318956",
"0.6029774",
"0.5809859",
"0.5809135",
"0.57811606",
"0.57792497",
"0.5717688",
"0.56928647",
"0.5680044",
"0.56697696",
"0.5665578",
"0.56534964",
"0.5587616",
"0.5578216",
"0.5575649",
"0.5569638",
"0.5555268",
"0.55517393",
"0.5528553",
"0.5528553",
"0.5523985... | 0.0 | -1 |
The out put is the embedding result of claim, sentence and the label which is totally 601 dimmensions I use word2vec for embedding and the structure of output for each claim and the sentence is [embedding claim_300 dimmensions, embedding each sentence in 5 documents_300 dimmensions, label] If the sentence is the eviden... | def Subtask4_pre_train_5():
with open(PATH + 'pre_train_4_Subtask4.txt', encoding='utf-8') as fi:
evi = eval(fi.read())
train_data = np.load(PATH + 'pre_train_2_Subtask4.npy', allow_pickle=True).item()
model = word2vec.KeyedVectors.load_word2vec_format(PATH + "data/GoogleNews-vectors-negative300.bi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, doc):\n out = torch.tensor([]).float().to(self.device)\n\n for i in range(len(doc)):\n sentences_raw = sentencesplit(cleantxt(doc[i]))\n sentences_ready = torch.tensor([]).float().to(self.device)\n for sentence in sentences_raw:\n sent... | [
"0.64397955",
"0.6414518",
"0.6299152",
"0.6277612",
"0.6267003",
"0.62635463",
"0.6263355",
"0.62268555",
"0.62209713",
"0.61678743",
"0.61583453",
"0.6140113",
"0.6101954",
"0.6095154",
"0.6061823",
"0.60469383",
"0.6040722",
"0.6030668",
"0.6017879",
"0.6002616",
"0.599854... | 0.6213321 | 9 |
This function is using the plot the ROC curve and print the RMSE, accuracy, AUC and test loss. The input is the prediction result of dev data and the label of dev data | def check_fit(truth, prob):
fpr, tpr, _ = roc_curve(truth, prob) # drop_intermediate:(default=True)
roc_auc = auc(fpr, tpr) # calculate the AUC
plt.figure()
plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=2, linesty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_ROC(model, x_test, y_test, save_folder): \n predicted = model.predict(x_test).ravel()\n actual = y_test.ravel()\n fpr, tpr, thresholds = roc_curve(actual, predicted, pos_label=None)\n roc_auc = auc(fpr, tpr)\n plt.title('Test ROC AUC')\n plt.plot(fpr, tpr, 'b', label='AUC = %0.3f' % roc_... | [
"0.76977634",
"0.76429826",
"0.74793595",
"0.7477506",
"0.74698573",
"0.7274968",
"0.7197911",
"0.7181239",
"0.71708226",
"0.71253717",
"0.7118289",
"0.71029097",
"0.71004033",
"0.70788234",
"0.70758516",
"0.7063369",
"0.7044861",
"0.70408773",
"0.70204055",
"0.70175385",
"0.... | 0.650461 | 45 |
The y_true is the label of dev data and the y_pred is the prediciton of the model | def precision_score(y_true, y_pred):
return ((y_true == 1) * (y_pred == 1)).sum() / (y_pred == 1).sum() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self, y_true, y_pred):\r\n pass",
"def _evaluate(self, y_true, y_pred):\n pass",
"def __call__(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:",
"def call(self, y_true, y_pred):\n y_true = K.switch(tf.shape(y_true)[-1] == self.n_classes, y_true, tf.squeeze(tf.one_hot(tf... | [
"0.75041443",
"0.735152",
"0.7322074",
"0.7288702",
"0.6739801",
"0.67297107",
"0.6712008",
"0.6712008",
"0.6710879",
"0.6695137",
"0.6695137",
"0.66806996",
"0.663322",
"0.6627519",
"0.6621446",
"0.6607797",
"0.65789884",
"0.6567409",
"0.6518728",
"0.6517879",
"0.6512908",
... | 0.0 | -1 |
The y_true is the label of dev data and the y_pred is the prediciton of the model | def recall_score(y_true, y_pred):
return ((y_true == 1) * (y_pred == 1)).sum() / (y_true == 1).sum() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self, y_true, y_pred):\r\n pass",
"def _evaluate(self, y_true, y_pred):\n pass",
"def __call__(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:",
"def call(self, y_true, y_pred):\n y_true = K.switch(tf.shape(y_true)[-1] == self.n_classes, y_true, tf.squeeze(tf.one_hot(tf... | [
"0.75036263",
"0.73512095",
"0.7322297",
"0.728788",
"0.6739536",
"0.67302555",
"0.67121196",
"0.67121196",
"0.6711572",
"0.66946733",
"0.66946733",
"0.66799456",
"0.6632211",
"0.662807",
"0.66207665",
"0.6607014",
"0.65800023",
"0.65667605",
"0.65185815",
"0.65180475",
"0.65... | 0.6182279 | 95 |
The y_true is the label of dev data and the y_pred is the prediciton of the model | def f1_score(y_true, y_pred):
num = 2 * precision_score(y_true, y_pred) * recall_score(y_true, y_pred)
deno = (precision_score(y_true, y_pred) + recall_score(y_true, y_pred))
return num / deno | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self, y_true, y_pred):\r\n pass",
"def _evaluate(self, y_true, y_pred):\n pass",
"def __call__(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:",
"def call(self, y_true, y_pred):\n y_true = K.switch(tf.shape(y_true)[-1] == self.n_classes, y_true, tf.squeeze(tf.one_hot(tf... | [
"0.7501048",
"0.73485255",
"0.732088",
"0.7285464",
"0.6736813",
"0.67290515",
"0.671074",
"0.6710235",
"0.6710235",
"0.66919374",
"0.66919374",
"0.66788685",
"0.66308594",
"0.6625441",
"0.6619626",
"0.6606853",
"0.65785164",
"0.6564014",
"0.65172786",
"0.6516026",
"0.6512531... | 0.0 | -1 |
Add modelspecific arguments to the parser. | def add_args(cls, parser):
dc = getattr(cls, "__dataclass", None)
if dc is not None:
# do not set defaults so that settings defaults from various architectures still works
gen_parser_from_dataclass(parser, dc(), delete_default=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_model_specific_args(parent_parser):\n # MODEL specific\n parser = ArgumentParser(parents=[parent_parser])\n parser.add_argument(\"--learning_rate\", default=0.01, type=float)\n parser.add_argument(\"--batch_size\", default=1, type=int)\n parser.add_argument(\"--depth\", d... | [
"0.78954256",
"0.7532234",
"0.75214946",
"0.7465922",
"0.7453896",
"0.73522615",
"0.7348936",
"0.7210105",
"0.71993154",
"0.7194432",
"0.718189",
"0.71380925",
"0.71294427",
"0.70640695",
"0.7035811",
"0.70225257",
"0.70146817",
"0.7005652",
"0.7005652",
"0.7002312",
"0.69814... | 0.6724837 | 28 |
Build a new model instance. | def build_model(cls, args, task):
raise NotImplementedError("Model must implement the build_model method") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_model(self):\n raise NotImplementedError",
"def build_model(self):\n pass",
"def build_model(self):\n pass",
"def build_model():",
"def _build_model(self, **kwargs):\n pass",
"def _build_model(self):\n raise NotImplementedError()",
"def build_model(self, **k... | [
"0.8193063",
"0.81708336",
"0.81708336",
"0.8142892",
"0.80082697",
"0.8007576",
"0.7792786",
"0.7418838",
"0.73600554",
"0.73502004",
"0.71278006",
"0.71252024",
"0.7077948",
"0.7076256",
"0.7055581",
"0.7055581",
"0.69957775",
"0.69957775",
"0.69845784",
"0.6895667",
"0.687... | 0.7413572 | 8 |
Get targets from either the sample or the net's output. | def get_targets(self, sample, net_output):
return sample["target"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_targets(self):\n\t\treturn self.prDoc['inputs']['data'][0]['targets']",
"def output_targets(self, input_targets):\n return input_targets",
"def output_targets(self) -> Set[str]:\n return {\n out.target\n for out in\n self.outputs\n }",
"def output... | [
"0.7546623",
"0.71686465",
"0.6932078",
"0.6811666",
"0.6767465",
"0.67216605",
"0.6592436",
"0.65119016",
"0.65086675",
"0.6496015",
"0.6452853",
"0.64246523",
"0.6375694",
"0.63572305",
"0.632819",
"0.62846535",
"0.6282436",
"0.6256334",
"0.622767",
"0.62171936",
"0.6214964... | 0.883374 | 0 |
Get normalized probabilities (or log probs) from a net's output. | def get_normalized_probs(
self,
net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],
log_probs: bool,
sample: Optional[Dict[str, Tensor]] = None,
):
return self.get_normalized_probs_scriptable(net_output, log_probs, sample) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_normalized_probs(self, net_output, log_probs, sample=None):\n encoder_out = net_output[\"encoder_out\"]\n if torch.is_tensor(encoder_out):\n logits = encoder_out.float()\n if log_probs:\n return F.log_softmax(logits, dim=-1)\n else:\n ... | [
"0.7654916",
"0.762612",
"0.7447698",
"0.7434408",
"0.7308484",
"0.72212243",
"0.65518427",
"0.61370546",
"0.61370546",
"0.6102418",
"0.6070036",
"0.60151446",
"0.59467596",
"0.5924957",
"0.58652586",
"0.58567977",
"0.57644725",
"0.5761727",
"0.5735097",
"0.57293767",
"0.5727... | 0.78670233 | 1 |
Scriptable helper function for get_normalized_probs in ~BaseFairseqModel | def get_normalized_probs_scriptable(
self,
net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],
log_probs: bool,
sample: Optional[Dict[str, Tensor]] = None,
):
if hasattr(self, "decoder"):
return self.decoder.get_normalized_probs(net_output, log... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_to_prob(inp):\n return (inp + 1)/2",
"def get_normalized_probs(\n self,\n net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],\n log_probs: bool,\n sample: Optional[Dict[str, Tensor]] = None,\n ):\n return self.get_normalized_probs_scripta... | [
"0.660994",
"0.6277411",
"0.6277411",
"0.615602",
"0.59609705",
"0.5934441",
"0.5852608",
"0.58386904",
"0.5791599",
"0.5754615",
"0.5637674",
"0.5621181",
"0.5581037",
"0.5580047",
"0.5567485",
"0.55672115",
"0.5557296",
"0.5536824",
"0.55352044",
"0.5490201",
"0.5468736",
... | 0.60832953 | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.