None:\n #TODO: type\n self.activation = self.params['activation']\n\n self.batchsize: int = self.params['batchsize']\n\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\n\n self.d: int = self.input_shape[1]\n assert(not self.d == 0)\n\n self.n: int = int(sqrt(self.input_shape[2]))\n assert(not self.n == 0)\n\n self.dtype: type = self.params['dtype']\n\n # initialize weights\n self.W: List[tf.Tensor] = []\n \n for i in range(3):\n #TODO: type\n w_init = self.params['initializer_w']\n if self.params['initializer_w' + str(i)] is not None:\n w_init = self.params['initializer_w' + str(i)]\n\n w_stddev: float = self.params['stddev_w']\n if self.params['stddev_w' + str(i)] is not None:\n w_stddev = self.params['stddev_w' + str(i)]\n\n self.W.append(tf.get_variable(\"weights_\" + str(i),\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\n dtype = self.dtype,\n initializer = w_init(stddev=w_stddev)))\n\n #TODO: type\n b_init = self.params['initializer_b']\n b_stddev = self.params['stddev_b']\n self.B: tf.Tensor = tf.get_variable(\"biases\", shape = (1, self.d, 1),\n dtype = self.dtype,\n initializer = b_init(stddev=b_stddev))\n\n # create/load expand matrix\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\n self.expand: tf.Tensor = tf.get_variable(\n \"expand\" + str(self.n),\n shape = (self.n, self.n * self.n),\n dtype = self.dtype,\n initializer = tf.constant_initializer(make_expand(self.n)))\n\n # create/load tile matrix\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\n for i in range(1, self.n):\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\n\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)","def init_emb(self):\r\n initrange = 0.5 / self.embedding_dim\r\n self.embeddings.weight.data.uniform_(-initrange, initrange)\r\n self.affine.weight.data.uniform_(-0, 0)\r\n self.affine.bias.data.zero_()","def _weight_initializer(self):\n for m in self.modules():\n if isinstance(m, nn.ConvTranspose2d):\n nn.init.kaiming_normal_(m.weight)\n elif isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1.0)\n nn.init.constant_(m.bias, 0.0)","def init_parameters(self):\n stdv = 1. / math.sqrt(self.weight.data.size(1))\n self.weight.data.uniform_(-stdv, stdv)\n if self.bias is not None:\n self.bias.data.uniform_(-stdv, stdv)","def __init__(self, embed_size):\n super(EncoderCNN, self).__init__()\n resnet = models.resnet152(pretrained=True)\n modules = list(resnet.children())[:-1] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\n self.init_weights()","def init_layer(layer):\n \n if layer.weight.ndimension() == 4:\n (n_out, n_in, height, width) = layer.weight.size()\n n = n_in * height * width\n \n elif layer.weight.ndimension() == 2:\n (n_out, n) = layer.weight.size()\n\n std = math.sqrt(2. / n)\n scale = std * math.sqrt(3.)\n layer.weight.data.uniform_(-scale, scale)\n\n if layer.bias is not None:\n layer.bias.data.fill_(0.)","def init_embedding_weights(self, dictionary, embeddings_index, embedding_dim):\r\n pretrained_weight = np.empty([len(dictionary), embedding_dim], dtype=float)\r\n for i in range(len(dictionary)):\r\n if dictionary.idx2word[i] in embeddings_index:\r\n pretrained_weight[i] = embeddings_index[dictionary.idx2word[i]]\r\n else:\r\n pretrained_weight[i] = helper.initialize_out_of_vocab_words(embedding_dim)\r\n # pretrained_weight is a numpy matrix of shape (num_embeddings, embedding_dim)\r\n if isinstance(self.embedding, nn.Sequential):\r\n self.embedding[0].weight.data.copy_(torch.from_numpy(pretrained_weight))\r\n else:\r\n self.embedding.weight.data.copy_(torch.from_numpy(pretrained_weight))","def setWeightInitializer(self,weights):\n self.init_w = weights","def initialize_weights(self):\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\n return w1, w2","def init_embedding(embeddings):\n bias = np.sqrt(3.0 / embeddings.size(1))\n torch.nn.init.uniform_(embeddings, -bias, bias)","def _init_weights(self):\n nn.init.xavier_normal_(self.out.weight)","def init_weights(self):\n for m in self.cls_convs:\n normal_init(m.conv, std=0.01)\n for m in self.reg_convs:\n normal_init(m.conv, std=0.01)\n normal_init(self.atss_reg, std=0.01)\n normal_init(self.atss_iou, std=0.01)\n bias_cls = bias_init_with_prob(0.01)\n normal_init(self.atss_cls, std=0.01, bias=bias_cls)","def init_weights(self):\n if self.init_cfg:\n super().init_weights()\n else:\n # Use smaller std for better stability and performance. We\n # use 0.1. See more details in \"ESRGAN: Enhanced Super-Resolution\n # Generative Adversarial Networks\"\n for m in [\n self.conv_first, self.conv_body, self.conv_up1,\n self.conv_up2, self.conv_hr, self.conv_last\n ]:\n default_init_weights(m, 0.1)","def init_weights(self):\n\n super().init_weights()\n\n init_type = None if self.init_cfg is None else self.init_cfg.get(\n 'type', None)\n if init_type != 'Pretrained' and self.with_tsa:\n for module in [\n self.fusion.feat_fusion, self.fusion.spatial_attn1,\n self.fusion.spatial_attn2, self.fusion.spatial_attn3,\n self.fusion.spatial_attn4, self.fusion.spatial_attn_l1,\n self.fusion.spatial_attn_l2, self.fusion.spatial_attn_l3,\n self.fusion.spatial_attn_add1\n ]:\n kaiming_init(\n module.conv,\n a=0.1,\n mode='fan_out',\n nonlinearity='leaky_relu',\n bias=0,\n distribution='uniform')","def init_weights(model):\n ...","def init_weights(self, init_w=3e-3):\n self.mean_linear.weight.data.uniform_(-init_w, init_w)\n self.mean_linear.bias.data.uniform_(-init_w, init_w)\n self.log_std_linear.weight.data.uniform_(-init_w, init_w)\n self.log_std_linear.bias.data.uniform_(-init_w, init_w)","def initialisation(self):\n self.create_variables()\n self.create_placeholders()\n self.build_model()\n self.reset_lr(None, True)\n self.build_loss()\n self.initialised = True","def _init_weights(self):\n for m in self.modules():\n if type(m) in {\n nn.Linear,\n nn.Conv3d,\n nn.Conv2d,\n nn.ConvTranspose2d,\n nn.ConvTranspose3d\n }:\n nn.init.kaiming_normal_(\n m.weight.data, a=0, mode='fan_out', nonlinearity='relu',\n )\n if m.bias is not None:\n fan_in, fan_out = \\\n nn.init._calculate_fan_in_and_fan_out(m.weight.data)\n bound = 1 / math.sqrt(fan_out)\n nn.init.normal_(m.bias, -bound, bound)","def _initialize_parameters(self):\n self.ent_emb = tf.get_variable('ent_emb', shape=[len(self.ent_to_idx), self.k * 2],\n initializer=self.initializer)\n self.rel_emb = tf.get_variable('rel_emb', shape=[len(self.rel_to_idx), self.k * 2],\n initializer=self.initializer)","def __init__(self, embed_size):\n super(EncoderCNN, self).__init__()\n resnet = models.resnet152(pretrained=True)\n modules = list(resnet.children())[:-1] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n self.pooling = nn.MaxPool2d(2,stride = 2)\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\n self.init_weights()","def __init__(self, layer_id,\n shape, X):\n prefix = 'Embedding' + layer_id\n self.n_words, self.in_size = shape\n\n # weights for embedding, the only parameters\n self.W = init_weights(shape=(self.n_words, self.in_size),\n name=prefix + '#W')\n\n self.params = [self.W]\n\n # Compute the embedded samples\n self.n_timesteps = X.shape[0]\n self.n_samples = X.shape[1]\n\n self.activation = self.W[X.flatten()].reshape([self.n_timesteps,\n self.n_samples,\n self.in_size])","def init_weights(self):\n r = np.sqrt(6.) / np.sqrt(self.fc1.in_features +\n self.fc1.out_features)\n self.fc1.weight.data.uniform_(-r, r)\n self.fc1.bias.data.fill_(0)\n r = np.sqrt(6.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)","def init_weights(layer):\r\n layer_name = layer.__class__.__name__\r\n if layer_name.find(\"Conv\") != -1:\r\n layer.weight.data.normal_(0.0, 0.02)\r\n elif layer_name.find(\"BatchNorm\") != -1:\r\n layer.weight.data.normal_(1.0, 0.02)\r\n layer.bias.data.fill_(0)","def _initialize_parameters(self):\n self.ent_emb = tf.get_variable('ent_emb', shape=[len(self.ent_to_idx), self.k],\n initializer=self.initializer)\n self.rel_emb = tf.get_variable('rel_emb', shape=[len(self.rel_to_idx), self.k],\n initializer=self.initializer)","def init_weights(self, dims):\n self.W = np.random.normal(size=dims) * 0.0001","def init_weights(self):\r\n constant_init(self.sampling_offsets, 0.)\r\n thetas = torch.arange(\r\n self.num_heads,\r\n dtype=torch.float32) * (2.0 * math.pi / self.num_heads)\r\n grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)\r\n grid_init = (grid_init /\r\n grid_init.abs().max(-1, keepdim=True)[0]).view(\r\n self.num_heads, 1, 1,\r\n 2).repeat(1, self.num_levels, self.num_points, 1)\r\n for i in range(self.num_points):\r\n grid_init[:, :, i, :] *= i + 1\r\n\r\n self.sampling_offsets.bias.data = grid_init.view(-1)\r\n constant_init(self.attention_weights, val=0., bias=0.)\r\n xavier_init(self.value_proj, distribution='uniform', bias=0.)\r\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\r\n self._is_init = True","def __init__(self, input_dim, output_dim, name='embedding_layer'):\n self.input_dim = input_dim\n self.output_dim = output_dim\n self.name = name\n\n # Randomly generate weights\n self.embeddings = shared((input_dim, output_dim),\n self.name + '__embeddings')\n\n # Define parameters\n self.params = [self.embeddings]","def _init_layers(self):\n self._init_predictor()\n if self.use_edge_fusion:\n self._init_edge_module()","def initialize_weights(self, input_dim, std_dev=1e-2):\n \n self.params = {}\n\n hidden_size = self.hidden_size\n num_classes = self.num_classes\n num_layers = self.num_layers\n #############################################################################\n # TODO: Initialize the weight and bias of every layer. Store the weights W #\n # of every layer in the dictionary names self.params. #\n # For example, Weights and bias of layer 1 will be stored in #\n # self.params[\"W1\"] and self.params[\"b1\"] respectively. #\n #############################################################################\n # input_dim * hidden_size\n self.params[\"W1\"] = np.random.randn(input_dim, self.hidden_size) * std_dev\n self.params[\"b1\"] = np.zeros(self.hidden_size)\n\n # hidden_size * num_classes\n self.params[\"W2\"] = np.random.randn(self.hidden_size, self.num_classes) * std_dev\n self.params[\"b2\"] = np.zeros(self.num_classes)\n #############################################################################\n # END OF YOUR CODE #\n ############################################################################# ","def _initialize_weights(self):\r\n for m in self.modules():\r\n if isinstance(m, nn.Conv2d):\r\n m.weight.data.normal_(0, 0.05)\r\n if m.bias is not None:\r\n m.bias.data.zero_()","def init_weights(self, pretrained):\n if self.with_shared_head:\n self.shared_head.init_weights(pretrained=pretrained)\n for i in range(1):\n if self.with_bbox:\n self.bbox_roi_extractor[i].init_weights()\n self.bbox_head[i].init_weights()\n if self.with_rbbox:\n self.rbbox_roi_extractor[i].init_weights()\n self.rbbox_head[i].init_weights()\n if self.with_mask:\n if not self.share_roi_extractor:\n self.mask_roi_extractor[i].init_weights()\n self.mask_head[i].init_weights()","def init_weights(self):\n\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\n self.fc3.out_features)\n self.fc3.weight.data.uniform_(-r, r)\n self.fc3.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc1.in_features +\n self.fc1.out_features)\n self.fc1.weight.data.uniform_(-r, r)\n self.fc1.bias.data.fill_(0)","def initialize_model(self):\n\n input_layer = Input(\n shape=(self.input_length,), \n dtype='int32', \n name='input'\n )\n\n if self.embedding_matrix is None:\n embedding = Embedding(\n output_dim=self.embedding_size,\n input_dim=self.vocabulary_size + 1, # for mask\n input_length=self.input_length,\n mask_zero=True,\n name='embedding'\n )(input_layer)\n else:\n embedding = Embedding(\n output_dim=self.embedding_size,\n input_dim=self.vocabulary_size + 1,\n input_length=self.input_length,\n mask_zero=True,\n weights=[np.vstack((np.zeros((1, self.embedding_size)),\n self.embedding_matrix))],\n name='embedding'\n )(input_layer)\n\n encoder = self.recurrent_cell(\n self.latent_dim,\n dropout=self.dropout,\n recurrent_dropout=self.dropout,\n name='encoder',\n recurrent_regularizer=l1_l2(*self.regularization)\n )\n\n if self.use_bidirection:\n encoder = Bidirectional(\n encoder,\n merge_mode='concat'\n )\n\n encoder = encoder(embedding)\n\n dense_1 = Dense(\n 1024,\n activation='tanh',\n name='dense_1',\n kernel_regularizer=l1_l2(*self.regularization)\n )(encoder)\n\n dense_2 = Dense(\n 512,\n activation='tanh',\n name='dense_2',\n kernel_regularizer=l1_l2(*self.regularization)\n )(dense_1)\n\n dropout = Dropout(self.dropout)(\n dense_2\n )\n\n prediction = Dense(\n 1,\n activation='sigmoid',\n name='prediction'\n )(dropout)\n\n model = Model(inputs=input_layer, outputs=prediction)\n\n # sparse_categorical_crossentropy\n model.compile(optimizer=Adam(lr=self.learning_rate),\n loss='binary_crossentropy',\n metrics=['acc'])\n\n self.model = model\n\n if self.verbose > 0:\n model.summary()\n\n return [model]"],"string":"[\n \"def init_weight(self):\\n init_layer(self.conv1)\\n init_layer(self.conv2)\\n init_bn(self.norm1)\\n init_bn(self.norm2)\",\n \"def instantiate_weights(self):\\n with tf.variable_scope(\\\"embedding_projection\\\"), tf.device('/cpu:0'): # embedding matrix\\n self.Embedding = tf.get_variable(\\\"Embedding\\\", shape=[self.vocab_size, self.embed_size],\\n initializer=self.initializer)\\n # self.Embedding_label = tf.get_variable(\\\"Embedding_label\\\", shape=[self.num_classes, self.embed_size],\\n # dtype=tf.float32) # ,initializer=self.initializer\\n # self.W_projection = tf.get_variable(\\\"W_projection\\\", shape=[self.sequence_length * self.d_model, self.num_classes],\\n # initializer=self.initializer) # [embed_size,label_size]\\n # self.b_projection = tf.get_variable(\\\"b_projection\\\", shape=[self.num_classes])\",\n \"def instantiate_weights(self):\\n self.product_embeddings = tf.get_variable(\\n name='product_embeddings',\\n shape=[50000, 300],\\n dtype=tf.float32\\n )\\n self.aisle_embeddings = tf.get_variable(\\n name='aisle_embeddings',\\n shape=[250, 50],\\n dtype=tf.float32\\n )\\n self.department_embeddings = tf.get_variable(\\n name='department_embeddings',\\n shape=[50, 10],\\n dtype=tf.float32\\n )\\n self.W_relu = tf.get_variable(\\\"W_relu\\\",shape=[670, 30]) #这个参数后续需要自适应\\n self.b_relu = tf.get_variable(\\\"bias_relu\\\",shape=[30]) \\n self.W_projection = tf.get_variable(\\\"W_projection\\\",shape=[30, 1]) \\n self.b_projection = tf.get_variable(\\\"bias_projection\\\",shape=[1])\",\n \"def instantiate_weights(self):\\n with tf.name_scope(\\\"decoder_init_state\\\"):\\n self.W_initial_state = tf.get_variable(\\\"W_initial_state\\\", shape=[self.hidden_size, self.hidden_size*2], initializer=self.initializer)\\n self.b_initial_state = tf.get_variable(\\\"b_initial_state\\\", shape=[self.hidden_size*2])\\n with tf.name_scope(\\\"embedding_projection\\\"): # embedding matrix\\n self.Embedding = tf.get_variable(\\\"Embedding\\\", shape=[self.vocab_size, self.embed_size],initializer=self.initializer) # [vocab_size,embed_size] tf.random_uniform([self.vocab_size, self.embed_size],-1.0,1.0)\\n self.Embedding_label = tf.get_variable(\\\"Embedding_label\\\", shape=[self.num_classes, self.embed_size*2],dtype=tf.float32) #,initializer=self.initializer\\n self.W_projection = tf.get_variable(\\\"W_projection\\\", shape=[self.hidden_size*2, self.num_classes],\\n initializer=self.initializer) # [embed_size,label_size]\\n self.b_projection = tf.get_variable(\\\"b_projection\\\", shape=[self.num_classes])\\n\\n # GRU parameters:update gate related\\n with tf.name_scope(\\\"gru_weights_encoder\\\"):\\n self.W_z = tf.get_variable(\\\"W_z\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.U_z = tf.get_variable(\\\"U_z\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.b_z = tf.get_variable(\\\"b_z\\\", shape=[self.hidden_size])\\n # GRU parameters:reset gate related\\n self.W_r = tf.get_variable(\\\"W_r\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.U_r = tf.get_variable(\\\"U_r\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.b_r = tf.get_variable(\\\"b_r\\\", shape=[self.hidden_size])\\n\\n self.W_h = tf.get_variable(\\\"W_h\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.U_h = tf.get_variable(\\\"U_h\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.b_h = tf.get_variable(\\\"b_h\\\", shape=[self.hidden_size])\\n\\n with tf.name_scope(\\\"gru_weights_decoder\\\"):\\n self.W_z_decoder = tf.get_variable(\\\"W_z_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.U_z_decoder = tf.get_variable(\\\"U_z_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.C_z_decoder = tf.get_variable(\\\"C_z_decoder\\\", shape=[self.embed_size * 2, self.hidden_size * 2],initializer=self.initializer) #TODO\\n self.b_z_decoder = tf.get_variable(\\\"b_z_decoder\\\", shape=[self.hidden_size*2])\\n # GRU parameters:reset gate related\\n self.W_r_decoder = tf.get_variable(\\\"W_r_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.U_r_decoder = tf.get_variable(\\\"U_r_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.C_r_decoder = tf.get_variable(\\\"C_r_decoder\\\", shape=[self.embed_size * 2, self.hidden_size * 2],initializer=self.initializer) #TODO\\n self.b_r_decoder = tf.get_variable(\\\"b_r_decoder\\\", shape=[self.hidden_size*2])\\n\\n self.W_h_decoder = tf.get_variable(\\\"W_h_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.U_h_decoder = tf.get_variable(\\\"U_h_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer) #TODO\\n self.C_h_decoder = tf.get_variable(\\\"C_h_decoder\\\", shape=[self.embed_size * 2, self.hidden_size * 2],initializer=self.initializer)\\n self.b_h_decoder = tf.get_variable(\\\"b_h_decoder\\\", shape=[self.hidden_size*2])\\n\\n with tf.name_scope(\\\"full_connected\\\"):\\n self.W_fc=tf.get_variable(\\\"W_fc\\\",shape=[self.hidden_size*2,self.hidden_size])\\n self.a_fc=tf.get_variable(\\\"a_fc\\\",shape=[self.hidden_size])\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.word.bias.data.fill_(0)\\n self.word.weight.data.uniform_(-0.1, 0.1)\",\n \"def initialize_weights(self):\\n for layer in self._cnn_layers:\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(layer)\",\n \"def initialize_weights(self, weights_initializer, bias_initializer):\\n wshapes = [\\n [self.input_size, self.hidden_size[0]],\\n [self.hidden_size[0], self.hidden_size[1]],\\n [self.hidden_size[1], self.output_size]\\n ]\\n\\n bshapes = [\\n [1, self.hidden_size[0]],\\n [1, self.hidden_size[1]],\\n [1, self.output_size]\\n ]\\n\\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\\n\\n self.trainable_variables = self.weights + self.biases\",\n \"def initialize_weights(self):\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(\\n self._batch)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\r\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\r\\n self.fc.bias.data.fill_(0)\\r\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def inputs_weights_init(self):\\n input_user, input_item, input_rating = self.inputs_init()\\n user_embeddings, item_embeddings = self.embeddings_layers_init()\\n\\n return input_user, input_item, input_rating, user_embeddings, item_embeddings\",\n \"def init_weights(self) -> None:\\n nn.init.kaiming_normal_(self._U)\\n nn.init.kaiming_normal_(self._W)\\n nn.init.kaiming_normal_(self._V)\\n\\n nn.init.normal_(self._b)\",\n \"def init_embedding(self):\\n self.embedding.weight.data.uniform_(-1./self.num_embeddings, 1./self.num_embeddings)\",\n \"def init_emb(self):\\n # Initialize users and items' embeddings\\n nn.init.xavier_uniform_(self.user_embedding.weight)\\n nn.init.xavier_uniform_(self.item_embedding.weight)\",\n \"def __init__(self, voc_size=8000, embed_size=100, hid_size=100, trunc=4,\\n model=None):\\n\\n self.log = logging.getLogger(\\\"TEST.Embed\\\")\\n self.log.setLevel(logging.INFO)\\n\\n self.unknown_token = \\\"UNKNOWN_TOKEN\\\"\\n self.sentence_start_token = \\\"SENTENCE_START\\\"\\n self.sentence_end_token = \\\"SENTENCE_END\\\"\\n\\n if model is None:\\n self.log.info(\\\"Initializing RNN parameters and functions...\\\")\\n\\n self.vocabulary_size = voc_size\\n self.embed_size = embed_size\\n self.hidden_size = hid_size\\n self.bptt_truncate = trunc\\n\\n # Instantiate the network weights\\n # I feel like the first and third are switched for some reason...\\n # but it's pretty consistent in the example code. Perhaps it's\\n # backwards for a purpose\\n # The weights going from the input layer to the word embedding\\n # layer (E, in tutorial)\\n weights_ie = np.random.uniform(-np.sqrt(1./voc_size),\\n np.sqrt(1./voc_size),\\n (embed_size, voc_size))\\n\\n # The weights going from input layer to hidden layer\\n # (U, in tutorial)\\n weights_eh = np.random.uniform(-np.sqrt(1./voc_size),\\n np.sqrt(1./voc_size),\\n (3, hid_size, embed_size))\\n\\n # The weights going from hidden layer to hidden layer\\n # (W, in tutorial)\\n weights_hh = np.random.uniform(-np.sqrt(1./voc_size),\\n np.sqrt(1./voc_size),\\n (3, hid_size, hid_size))\\n\\n # The weights going from hidden layer to output layer\\n # (V, in tutorial)\\n weights_ho = np.random.uniform(-np.sqrt(1./voc_size),\\n np.sqrt(1./voc_size),\\n (voc_size, hid_size))\\n\\n # The bias for the hidden units (no bias applied to embedding layer)\\n bias = np.zeros((3, hid_size))\\n\\n # The bias for the output units\\n out_bias = np.zeros(voc_size)\\n\\n self.weights_ie = theano.shared(\\n name='weights_ie',\\n value=weights_ie.astype(theano.config.floatX))\\n\\n self.weights_eh = theano.shared(\\n name='weights_eh',\\n value=weights_eh.astype(theano.config.floatX))\\n\\n self.weights_hh = theano.shared(\\n name='weights_hh',\\n value=weights_hh.astype(theano.config.floatX))\\n\\n self.weights_ho = theano.shared(\\n name='weights_ho',\\n value=weights_ho.astype(theano.config.floatX))\\n\\n self.bias = theano.shared(\\n name='bias',\\n value=bias.astype(theano.config.floatX))\\n\\n self.out_bias = theano.shared(\\n name='out_bias',\\n value=out_bias.astype(theano.config.floatX))\\n\\n self.cache_ie = theano.shared(\\n name='cache_ie',\\n value=np.zeros(weights_ie.shape).astype(theano.config.floatX))\\n\\n self.cache_eh = theano.shared(\\n name='cache_eh',\\n value=np.zeros(weights_eh.shape).astype(theano.config.floatX))\\n\\n self.cache_hh = theano.shared(\\n name='cache_hh',\\n value=np.zeros(weights_hh.shape).astype(theano.config.floatX))\\n\\n self.cache_ho = theano.shared(\\n name='cache_ho',\\n value=np.zeros(weights_ho.shape).astype(theano.config.floatX))\\n\\n self.cache_bias = theano.shared(\\n name='cache_bias',\\n value=np.zeros(bias.shape).astype(theano.config.floatX))\\n\\n self.cache_out_bias = theano.shared(\\n name='cache_out_bias',\\n value=np.zeros(out_bias.shape).astype(theano.config.floatX))\\n\\n self.vocabulary = []\\n self.word_to_index = {}\\n self.index_to_word = []\\n else:\\n self.log.info(\\\"Loading model parameters from saved model...\\\")\\n\\n with open(model, \\\"rb\\\") as modelFile:\\n params = cPickle.load(modelFile)\\n\\n self.vocabulary_size = params[0]\\n self.embed_size = params[1]\\n self.hidden_size = params[2]\\n self.bptt_truncate = params[3]\\n\\n self.weights_ie = params[4]\\n self.weights_eh = params[5]\\n self.weights_hh = params[6]\\n self.weights_ho = params[7]\\n\\n self.vocabulary = params[8]\\n if not self.vocabulary[-1] == self.unknown_token:\\n self.log.info(\\\"Appending unknown token\\\")\\n self.vocabulary[-1] = self.unknown_token\\n self.index_to_word = params[9]\\n self.word_to_index = params[10]\\n\\n self.bias = params[11]\\n self.out_bias = params[12]\\n\\n self.cache_ie = params[13]\\n self.cache_eh = params[14]\\n self.cache_hh = params[15]\\n self.cache_ho = params[16]\\n self.cache_bias = params[17]\\n self.cache_out_bias = params[18]\\n # End of if statement\\n\\n # Symbolic representation of one input sentence\\n input = T.ivector('sentence')\\n\\n # Symbolic representation of the one output sentence\\n output = T.ivector('sentence')\\n\\n # Symbolic representation of the cache decay for RMSprop\\n decay = T.scalar('decay')\\n\\n # Stochastic Gradient Descent step\\n learning_rate = T.scalar('learning_rate')\\n\\n def forward_propagate(word, previous_state):\\n \\\"\\\"\\\"\\n Vertically propagates one of the words.\\n\\n :type word: int\\n :param word: the index of the current input word\\n\\n :type previous_state: T.dvector()\\n :param word: the output of the hidden layer from the previous\\n horizontal layer\\n \\\"\\\"\\\"\\n # Embedding layer\\n word_vector = self.weights_ie[:, word]\\n\\n # GRU layer\\n update_gate = T.nnet.hard_sigmoid(\\n self.weights_eh[0].dot(word_vector) +\\n self.weights_hh[0].dot(previous_state) +\\n self.bias[0]\\n )\\n\\n reset_gate = T.nnet.hard_sigmoid(\\n self.weights_eh[1].dot(word_vector) +\\n self.weights_hh[1].dot(previous_state) +\\n self.bias[1]\\n )\\n\\n hypothesis = T.tanh(\\n self.weights_eh[2].dot(word_vector) +\\n self.weights_hh[2].dot(previous_state * reset_gate) +\\n self.bias[2]\\n )\\n\\n current_state = (T.ones_like(update_gate) - update_gate) * hypothesis + update_gate * previous_state\\n\\n # Output layer\\n current_output = T.nnet.softmax(\\n self.weights_ho.dot(current_state) + self.out_bias\\n )[0]\\n\\n # Not sure why current_output[0] and not just current_output...\\n return [current_output, current_state]\\n\\n #######################################################################\\n # Symbolically represents going through each input sentence word and\\n # then calculating the state of the hidden layer and output word for\\n # each word. The forward_propagate function is the one used to\\n # generate the output word and hidden layer state.\\n #######################################################################\\n self.theano = {}\\n\\n [out, state], updates = theano.scan(\\n forward_propagate,\\n sequences=input,\\n truncate_gradient=self.bptt_truncate,\\n outputs_info=[None, dict(initial=T.zeros(self.hidden_size))],\\n name=\\\"forward_propagate\\\"\\n )\\n\\n # Predicts the output words for each word in the sentence\\n prediction = T.argmax(out, axis=1)\\n\\n # Calculates the output error between the predicted output and the\\n # actual output\\n out_error = T.sum(T.nnet.categorical_crossentropy(out, output))\\n\\n # Symbolically represents gradient calculations for gradient descent\\n d_weights_ie = T.grad(out_error, self.weights_ie)\\n d_weights_eh = T.grad(out_error, self.weights_eh)\\n d_weights_hh = T.grad(out_error, self.weights_hh)\\n d_weights_ho = T.grad(out_error, self.weights_ho)\\n d_bias = T.grad(out_error, self.bias)\\n d_out_bias = T.grad(out_error, self.out_bias)\\n\\n # Symbolic theano functions\\n self.forward_propagate = theano.function([input], out,\\n name=\\\"forward_propagate\\\")\\n self.predict = theano.function([input], prediction, name=\\\"predict\\\")\\n self.calculate_error = theano.function([input, output], out_error,\\n name=\\\"calculate_error\\\")\\n self.bptt = theano.function([input, output],\\n [d_weights_ie, d_weights_eh, d_weights_hh, d_weights_ho, d_bias,\\n d_out_bias],\\n name=\\\"bptt\\\")\\n\\n # RMSprop parameters\\n cache_ie = (decay * self.cache_ie) + ((1 - decay) * d_weights_ie ** 2)\\n cache_eh = (decay * self.cache_eh) + ((1 - decay) * d_weights_eh ** 2)\\n cache_hh = (decay * self.cache_hh) + ((1 - decay) * d_weights_hh ** 2)\\n cache_ho = (decay * self.cache_ho) + ((1 - decay) * d_weights_ho ** 2)\\n cache_bias = (decay * self.cache_bias) + ((1 - decay) * d_bias ** 2)\\n cache_out_bias = (decay * self.cache_out_bias) + ((1 - decay) * d_out_bias ** 2)\\n eps = 1e-6 # Prevents division by 0\\n\\n self.sgd_step = theano.function(\\n [input, output, learning_rate, theano.In(decay, value=0.9)],\\n [],\\n updates=[\\n (self.weights_ie, self.weights_ie - learning_rate *\\n d_weights_ie / (T.sqrt(self.cache_ie + eps))),\\n (self.weights_eh, self.weights_eh - learning_rate *\\n d_weights_eh / (T.sqrt(self.cache_eh + eps))),\\n (self.weights_hh, self.weights_hh - learning_rate *\\n d_weights_hh / (T.sqrt(self.cache_hh + eps))),\\n (self.weights_ho, self.weights_ho - learning_rate *\\n d_weights_ho / (T.sqrt(self.cache_ho + eps))),\\n (self.bias, self.bias - learning_rate * d_bias /\\n (T.sqrt(self.cache_bias + eps))),\\n (self.out_bias, self.out_bias - learning_rate *\\n d_out_bias / (T.sqrt(self.cache_out_bias + eps))),\\n (self.cache_ie, cache_ie),\\n (self.cache_eh, cache_eh),\\n (self.cache_hh, cache_hh),\\n (self.cache_ho, cache_ho),\\n (self.cache_bias, cache_bias),\\n (self.cache_out_bias, cache_out_bias)]\\n )\\n\\n self.x_train = None\\n self.y_train = None\",\n \"def InitWeights(self):\\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\\n self.w0 = -1 + 2 * np.random.rand()\",\n \"def _initialize_weights(self):\\n pass\",\n \"def init_parameters(self):\\n # Create the weights and biases\\n for i in range(1, len(self.layer_dimensions)):\\n # Initialization from He et al.\\n mu = 0\\n var = 2 / self.layer_dimensions[i]\\n sigma = np.sqrt(var)\\n weight_shape = (self.layer_dimensions[i - 1], self.layer_dimensions[i])\\n weight = np.random.normal(loc=mu, scale=sigma, size=weight_shape)\\n bias = np.zeros((self.layer_dimensions[i], ))\\n\\n # Saving in the parameters dict\\n layer_weight = \\\"w_\\\" + str(i)\\n self._parameters[layer_weight] = weight\\n layer_b = \\\"b_\\\" + str(i)\\n self._parameters[layer_b] = bias\",\n \"def params_init(self) -> None:\\n # Initialize weights and biases with uniform distribution.\\n nn.init.uniform_(self.emb.weight, self.init_lower, self.init_upper)\\n nn.init.uniform_(self.fc_e2h[1].weight, self.init_lower, self.init_upper)\\n nn.init.uniform_(self.fc_e2h[1].bias, self.init_lower, self.init_upper)\\n for lyr in range(self.n_lyr):\\n self.stack_rnn[2 * lyr].params_init()\\n nn.init.uniform_(self.fc_h2e[0].weight, self.init_lower, self.init_upper)\\n nn.init.uniform_(self.fc_h2e[0].bias, self.init_lower, self.init_upper)\",\n \"def init_weight(self):\\n init_bn(self.norm0)\",\n \"def init_layers(self):\\n self.user_emb = nn.Embedding(self.n_users, self.emb_dim)\\n self.item_emb = nn.Embedding(self.n_items, self.emb_dim)\\n init_range = 0.1 * (self.emb_dim) ** (-1 / 2)\\n self.item_emb.weight.data.uniform_(-init_range, init_range)\\n self.fc_u_1_mu = nn.Linear(self.user_fea_dim, self.late_dim)\\n self.fc_u_2_mu = nn.Linear(self.late_dim, self.emb_dim * 2)\\n self.fc_i_1_mu = nn.Linear(self.item_fea_dim, self.late_dim)\\n self.fc_i_2_mu = nn.Linear(self.late_dim, self.emb_dim * 2)\",\n \"def initialize_weights(self):\\n tf.nest.map_structure(\\n weights_initializer.WeightsInitializer.initialize_layer_or_model,\\n self._layer_nest)\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\",\n \"def _init_layers(self) -> None:\\n weight_nums, bias_nums = [], []\\n for i in range(self.num_layers):\\n if i == 0:\\n weight_nums.append((self.in_channels + 2) * self.feat_channels)\\n bias_nums.append(self.feat_channels)\\n elif i == self.num_layers - 1:\\n weight_nums.append(self.feat_channels * 1)\\n bias_nums.append(1)\\n else:\\n weight_nums.append(self.feat_channels * self.feat_channels)\\n bias_nums.append(self.feat_channels)\\n\\n self.weight_nums = weight_nums\\n self.bias_nums = bias_nums\\n self.num_params = sum(weight_nums) + sum(bias_nums)\",\n \"def init_weights(self):\\n self._q_neuron.h(self._weights) \\n self._q_neuron.x(self._weights)\",\n \"def init_weights(self):\\n # We don't use the `init_weights()` function in BaseModule, since it\\n # doesn't support the initialization method from `reset_parameters()`\\n # in Pytorch.\\n if self.with_backbone:\\n self.backbone.init_weights()\\n\\n if self.with_neck:\\n for m in self.neck.modules():\\n if isinstance(m, _ConvNd) or isinstance(m, _BatchNorm):\\n m.reset_parameters()\\n\\n if self.with_head:\\n for m in self.head.modules():\\n if isinstance(m, _ConvNd) or isinstance(m, _BatchNorm):\\n m.reset_parameters()\",\n \"def init_weights(self):\\n\\n params = torch.load(self.resnet_weight)\\n\\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\\n\\n\\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\\n self.fc3.out_features)\\n self.fc3.weight.data.uniform_(-r, r)\\n self.fc3.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\\n self.fc4.out_features)\\n self.fc4.weight.data.uniform_(-r, r)\\n self.fc4.bias.data.fill_(0)\",\n \"def reset_weights(self):\\n np.random.seed(self.seed)\\n self.node_embedding = xavier_normal(size=(self.vocab_size, self.layer1_size), as_type=np.float32)\\n self.context_embedding = xavier_normal(size=(self.vocab_size, self.layer1_size), as_type=np.float32)\\n\\n\\n self.centroid = np.zeros((self.k, self.layer1_size), dtype=np.float32)\\n self.covariance_mat = np.zeros((self.k, self.layer1_size, self.layer1_size), dtype=np.float32)\\n self.inv_covariance_mat = np.zeros((self.k, self.layer1_size, self.layer1_size), dtype=np.float32)\\n self.pi = np.zeros((self.vocab_size, self.k), dtype=np.float32)\",\n \"def init_weights(self, load_weights=None):\\n if load_weights:\\n # TODO\\n pass\\n else:\\n # x: lower layer nodes n\\n # y: current layer nodes n\\n x = self.weights_shape[1]\\n y = self.weights_shape[0]\\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member\",\n \"def _create_weights(self):\\n\\n self.mu_W = tf.get_variable(\\n name=\\\"mu_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim, self.z_dim])\\n\\n self.mu_b = tf.get_variable(\\n name=\\\"mu_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.z_dim])\\n\\n self.log_sig_sq_W = tf.get_variable(\\n name=\\\"log_sig_sq_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim, self.z_dim])\\n\\n self.log_sig_sq_b = tf.get_variable(\\n name=\\\"log_sig_sq_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.z_dim])\\n \\n self.y_W = tf.get_variable(\\n name=\\\"y_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.z_dim, self.rnn_dim])\\n\\n self.y_b = tf.get_variable(\\n name=\\\"y_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim])\\n \\n self.softmax_W = tf.get_variable(\\n name=\\\"softmax_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim, self.vocabulary_size])\\n \\n self.softmax_b = tf.get_variable(\\n name=\\\"softmax_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.vocabulary_size])\",\n \"def reset_parameters(self):\\n logger.info('===== Initialize %s =====' % self.__class__.__name__)\\n nn.init.normal_(self.embed.weight, mean=0.0, std=self.d_model ** -0.5)\\n nn.init.constant_(self.embed.weight[self.pad], 0)\\n if self.output is not None and not self.tie_embedding:\\n nn.init.xavier_uniform_(self.output.weight)\\n nn.init.constant_(self.output.bias, 0.0)\",\n \"def initialise_parameters(self):\\n # Weights\\n init = select_w_init(self.w_init)\\n if self.w_gain:\\n gain = nn.init.calculate_gain('relu')\\n init(self.relations, gain=gain)\\n else:\\n init(self.relations)\\n\\n # Biases\\n if self.b_init:\\n init = select_b_init(self.b_init)\\n init(self.sbias)\\n init(self.pbias)\\n init(self.obias)\",\n \"def _initialize_embeddings(self):\\n with tf.variable_scope(self.scope):\\n init_temporal_s = np.sqrt(\\n 6. / (self._config.nact_dict[\\\"num_s\\\"] + self._config.ndim_emb + 1))\\n\\n self.w_dt = tf.get_variable(\\n name=\\\"w_dt\\\",\\n shape=[1, self._config.ndim_emb],\\n initializer=tf.initializers.random_uniform(\\n -init_temporal_s, init_temporal_s))\\n\\n if self._config.embedding_type not in self._embedding_classes:\\n raise ValueError(\\n f\\\"Unknown embedding type: {self._config.embedding_type}.\\\")\\n self.embedding = self._embedding_classes[self._config.embedding_type](\\n self._config, self._embed_dim_dict)\",\n \"def init_weights_(self):\\n raise NotImplementedError\",\n \"def build_layer(self) :\\n inputsWithBias = self.input_count + 1\\n self.weights = np.random.rand(inputsWithBias, self.node_count)\\n self.weights_and_activations = (self.weights, self.activations)\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\\n # Tie weights if needed\\n self.tie_weights()\",\n \"def _init_layers(self) -> None:\\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\\n self.cross_attn = MultiheadAttention(**self.cross_attn_cfg)\\n self.embed_dims = self.self_attn.embed_dims\\n self.ffn = FFN(**self.ffn_cfg)\\n norms_list = [\\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\\n for _ in range(3)\\n ]\\n self.norms = ModuleList(norms_list)\",\n \"def init_weights(self):\\n \\n self.w = np.random.randn(self.D) / np.sqrt(self.D)\",\n \"def _initialize_weights(self):\\n stddev = 1.0 / math.sqrt(self._hidden_size)\\n for layer_id, param_id in itertools.product(\\n range(self._num_layers * (self._bidirectional + 1)),\\n range(self._num_gates * 2)):\\n i = layer_id * 2 + (param_id // self._num_gates)\\n j = i + len(self._weights_shapes) // 2\\n matrix_shape = self._weights_shapes[i][:]\\n bias_shape = self._weights_shapes[j][:]\\n matrix_shape[0] //= self._num_gates\\n bias_shape[0] //= self._num_gates\\n self._set_parameter(\\n init_ops.random_uniform(matrix_shape, -stddev, stddev),\\n layer_id, param_id, 'matrix')\\n self._set_parameter(\\n init_ops.random_uniform(bias_shape, -stddev, stddev),\\n layer_id, param_id, 'bias')\",\n \"def init_weights(self, leveledinit: bool, kernel_size: int, bias: bool) -> None:\\n if leveledinit:\\n nn.init.normal_(self.conv1d.weight, std=1e-3)\\n nn.init.normal_(self.conv1d.bias, std=1e-6)\\n with torch.no_grad():\\n self.conv1d.weight[:, 0, :] += 1.0 / kernel_size\\n else:\\n nn.init.xavier_uniform_(self.conv1d.weight)\\n\\n if self.embed in (\\\"pre\\\", \\\"post\\\"):\\n nn.init.xavier_uniform_(self.embedding.weight)\",\n \"def init_params(self):\\n self.conv = Conv(self.conv_layers[0][-1], self.out_channels, padding=self.padding,stride=self.stride)\\n self.W = torch.randn(self.num_labels, self.cout_numel, requires_grad=True)\\n self.T = torch.randn(self.num_labels, self.num_labels, requires_grad=True)\",\n \"def _init_layers(self) -> None:\\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\\n self.embed_dims = self.self_attn.embed_dims\\n self.ffn = FFN(**self.ffn_cfg)\\n norms_list = [\\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\\n for _ in range(2)\\n ]\\n self.norms = ModuleList(norms_list)\",\n \"def __init__(self, embed_size, hidden_size, vocab_size, num_layers):\\n super(DecoderRNN, self).__init__()\\n self.embed = nn.Embedding(vocab_size, embed_size)\\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\\n self.linear = nn.Linear(hidden_size, vocab_size)\\n self.init_weights()\",\n \"def initWeights(self):\\n self.weights = []\\n self.bias = []\\n for i, dim in enumerate(self.dimensions[1:]):\\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\\n self.bias.append(np.random.uniform(-1,1,dim))\",\n \"def embeddings_layers_init(self):\\n\\n user_embeddings = tf.keras.layers.Embedding(\\n self.n_users, self.user_dim, input_length=1)\\n\\n item_embeddings = tf.keras.layers.Embedding(\\n self.n_items, self.item_dim, input_length=1)\\n\\n return user_embeddings, item_embeddings\",\n \"def build(self):\\n\\n self.W = self.init([self.n_atom_input_feat, self.n_output])\\n self.b = model_ops.zeros(shape=[\\n self.n_output,\\n ])\\n\\n self.trainable_weights = self.W + self.b\",\n \"def _initialize_weights(self):\\n for _, cell in self.cells_and_names():\\n if isinstance(cell, nn.Conv2d):\\n cell.weight.set_data(orthogonal(cell.weight.shape, 0.6))\\n if cell.bias is not None:\\n cell.bias.set_data(\\n init.initializer(init.Constant(0.01), cell.bias.shape,\\n cell.bias.dtype))\",\n \"def initialize_parameters(self):\\n for i in range(1, self.L):\\n self.W[i - 1] = np.random.randn(self.layer_dims[i], self.layer_dims[i - 1]) * 0.01\\n self.b[i - 1] = np.zeros((self.layer_dims[i], 1))\",\n \"def _init_weights(self):\\n for layer in self.modules():\\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\\n nn.init.xavier_uniform_(layer.weight)\\n if layer.bias is not None:\\n nn.init.constant_(layer.bias, 0)\\n elif isinstance(layer, nn.BatchNorm1d):\\n nn.init.constant_(layer.weight, 1)\\n nn.init.constant_(layer.bias, 0)\",\n \"def _init_weights(self):\\n for layer in self.modules():\\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\\n nn.init.xavier_uniform_(layer.weight)\\n if layer.bias is not None:\\n nn.init.constant_(layer.bias, 0)\\n elif isinstance(layer, nn.BatchNorm1d):\\n nn.init.constant_(layer.weight, 1)\\n nn.init.constant_(layer.bias, 0)\",\n \"def _init_weights(self):\\n for layer in self.modules():\\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\\n nn.init.xavier_uniform_(layer.weight)\\n if layer.bias is not None:\\n nn.init.constant_(layer.bias, 0)\\n elif isinstance(layer, nn.BatchNorm1d):\\n nn.init.constant_(layer.weight, 1)\\n nn.init.constant_(layer.bias, 0)\",\n \"def init_weights(self, init_w=3e-3):\\n self.l3.weight.data.uniform_(-init_w, init_w)\\n self.l3.bias.data.uniform_(-init_w, init_w)\",\n \"def init_weights(self, init_w=3e-3):\\n self.l3.weight.data.uniform_(-init_w, init_w)\\n self.l3.bias.data.uniform_(-init_w, init_w)\",\n \"def init_weights(self, pretrained=None):\\n super(SingleTwoStageDetector176PRW, self).init_weights(pretrained)\\n self.backbone.init_weights(pretrained=pretrained)\\n if self.with_neck:\\n if isinstance(self.neck, nn.Sequential):\\n for m in self.neck:\\n m.init_weights()\\n else:\\n self.neck.init_weights()\\n if self.with_rpn:\\n self.rpn_head.init_weights()\\n if self.with_roi_head:\\n self.roi_head.init_weights(pretrained)\\n self.bbox_head.init_weights()\",\n \"def init_weights(self):\\n with torch.no_grad():\\n self._init_weights()\",\n \"def init_weights(self):\\n self.transformer.init_weights()\\n if self.loss_cls.use_sigmoid:\\n bias_init = bias_init_with_prob(0.01)\\n for m in self.cls_branches:\\n nn.init.constant_(m[-1].bias, bias_init)\",\n \"def init_weights(self):\\n for m in self.cls_convs:\\n normal_init(m.conv, std=0.01)\\n for m in self.reg_convs:\\n normal_init(m.conv, std=0.01)\\n bias_cls = bias_init_with_prob(0.01)\\n normal_init(self.retina_cls, std=0.01, bias=bias_cls)\\n normal_init(self.retina_reg, std=0.01)\",\n \"def __init__(self, inputSize, hiddenSize, outputSize, epochs = 100, debug = False):\\n self.inputSize = inputSize\\n self.hiddenSize = hiddenSize\\n self.outputSize = outputSize\\n self.epochs = epochs\\n self.debug = debug\\n\\n #weights\\n self.W1 = np.random.randn(self.inputSize, self.hiddenSize) \\n self.W2 = np.random.randn(self.hiddenSize, self.outputSize)\",\n \"def __init__(self,embedding_size):\\n super(ResNetEncoder,self).__init__()\\n resnet = models.resnet50(pretrained=True)\\n modules = list(resnet.children())[:-1]\\n #Create a sequential models upto top fc layer add a custom fc layer compatible with embedding size of decoder RNN\\n self.resnet = nn.Sequential(*modules)\\n self.embed = nn.Linear(resnet.fc.in_features,embedding_size)\\n self.bn = nn.BatchNorm1d(embedding_size,momentum=0.01)\\n self.init_weights()\",\n \"def __init__(self):\\r\\n # A dummy layer does nothing\\r\\n self.weights = np.zeros(shape=(input.shape[1], 10))\\r\\n bias = np.zeros(shape=(10,))\\r\\n pass\",\n \"def init_weights(self) -> None:\\n super().init_weights()\\n kaiming_init(self.convs_all_levels, a=1, distribution='uniform')\\n kaiming_init(self.conv_branch, a=1, distribution='uniform')\\n kaiming_init(self.conv_pred, a=1, distribution='uniform')\",\n \"def initialise_parameters(self):\\n\\n\\t\\tlow = -numpy.sqrt(6/(self.input_dimension + self.hidden_dimension))\\n\\t\\thigh = numpy.sqrt(6/(self.input_dimension + self.hidden_dimension))\\n\\t\\tif self.activation is theano.tensor.nnet.sigmoid:\\n\\t\\t\\t# We know the optimum distribution for tanh and sigmoid, so we\\n\\t\\t\\t# assume that we're using tanh unless we're using sigmoid.\\n\\t\\t\\tlow *= 4\\n\\t\\t\\thigh *= 4\\n\\n\\t\\tself.weights = theano.shared(\\n\\t\\t\\tvalue=numpy.asarray(\\n\\t\\t\\t\\tself.rng.uniform( # This distribution is apparently optimal for tanh.\\n\\t\\t\\t\\t\\tlow=low,\\n\\t\\t\\t\\t\\thigh=high,\\n\\t\\t\\t\\t\\tsize=(self.input_dimension, self.hidden_dimension)),\\n\\t\\t\\t\\tdtype=theano.config.floatX),\\n\\t\\t\\tname=\\\"W\\\",\\n\\t\\t\\tborrow=True)\\n\\n\\t\\tself.bias = theano.shared(\\n\\t\\t\\tvalue=numpy.zeros((self.hidden_dimension,),\\n\\t\\t\\t\\tdtype=theano.config.floatX),\\n\\t\\t\\tname=\\\"b\\\",\\n\\t\\t\\tborrow=True)\\n\\n\\t\\tself.reverse_bias = theano.shared(\\n\\t\\t\\tvalue=numpy.zeros((self.input_dimension,),\\n\\t\\t\\t\\tdtype=theano.config.floatX),\\n\\t\\t\\tname=\\\"b'\\\",\\n\\t\\t\\tborrow=True)\\n\\n\\t\\tself.reverse_weights = self.weights.T\\t# Tied weights, so the reverse weight\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# matrix is just the transpose.\\n\\n\\t\\tself.label_weights = theano.shared(\\n\\t\\t\\tvalue=numpy.zeros((self.hidden_dimension, self.output_dimension),\\n\\t\\t\\t\\tdtype=theano.config.floatX),\\n\\t\\t\\tname=\\\"lW\\\",\\n\\t\\t\\tborrow=True)\\n\\n\\t\\tself.label_bias = theano.shared(\\n\\t\\t\\tvalue=numpy.zeros((self.output_dimension,),\\n\\t\\t\\t\\tdtype=theano.config.floatX),\\n\\t\\t\\tname=\\\"lb\\\",\\n\\t\\t\\tborrow=True)\",\n \"def _weight_initializer(self):\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n nn.init.kaiming_normal_(m.weight)\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1.0)\\n nn.init.constant_(m.bias, 0.0)\",\n \"def init_weights(self, pretrained=None):\\n self.online_backbone.init_weights() # backbone\\n for online_neck in self.online_necks:\\n online_neck.init_weights(init_linear='kaiming') # projection\\n\\n for param_ol, param_tgt in zip(self.online_backbone.parameters(),\\n self.target_backbone.parameters()):\\n param_tgt.data.copy_(param_ol.data)\\n for param_ol, param_tgt in zip(self.online_necks.parameters(),\\n self.target_necks.parameters()):\\n param_tgt.data.copy_(param_ol.data)\\n # init the predictor in the head\\n for head in self.heads:\\n head.init_weights()\",\n \"def initialize_weights(self):\\n # compute lmda.\\n self.lmda = float(self.c)/float(self.N)\\n # bias term. This should not get a regularization penalty.\\n self.bias = {}\\n # weight vector\\n self.w = {}\\n # lastW[j] = k, indicates that feature j was last updated at time k.\\n self.lastW = {}\\n for lbl in self.labels:\\n self.bias[lbl] = 0\\n self.w[lbl] = {}\\n self.lastW[lbl] = {}\\n pass\",\n \"def _setup(self) -> None:\\n #TODO: type\\n self.activation = self.params['activation']\\n\\n self.batchsize: int = self.params['batchsize']\\n\\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\\n\\n self.d: int = self.input_shape[1]\\n assert(not self.d == 0)\\n\\n self.n: int = int(sqrt(self.input_shape[2]))\\n assert(not self.n == 0)\\n\\n self.dtype: type = self.params['dtype']\\n\\n # initialize weights\\n self.W: List[tf.Tensor] = []\\n \\n for i in range(3):\\n #TODO: type\\n w_init = self.params['initializer_w']\\n if self.params['initializer_w' + str(i)] is not None:\\n w_init = self.params['initializer_w' + str(i)]\\n\\n w_stddev: float = self.params['stddev_w']\\n if self.params['stddev_w' + str(i)] is not None:\\n w_stddev = self.params['stddev_w' + str(i)]\\n\\n self.W.append(tf.get_variable(\\\"weights_\\\" + str(i),\\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\\n dtype = self.dtype,\\n initializer = w_init(stddev=w_stddev)))\\n\\n #TODO: type\\n b_init = self.params['initializer_b']\\n b_stddev = self.params['stddev_b']\\n self.B: tf.Tensor = tf.get_variable(\\\"biases\\\", shape = (1, self.d, 1),\\n dtype = self.dtype,\\n initializer = b_init(stddev=b_stddev))\\n\\n # create/load expand matrix\\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\\n self.expand: tf.Tensor = tf.get_variable(\\n \\\"expand\\\" + str(self.n),\\n shape = (self.n, self.n * self.n),\\n dtype = self.dtype,\\n initializer = tf.constant_initializer(make_expand(self.n)))\\n\\n # create/load tile matrix\\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\\n for i in range(1, self.n):\\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\\n\\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)\",\n \"def init_emb(self):\\r\\n initrange = 0.5 / self.embedding_dim\\r\\n self.embeddings.weight.data.uniform_(-initrange, initrange)\\r\\n self.affine.weight.data.uniform_(-0, 0)\\r\\n self.affine.bias.data.zero_()\",\n \"def _weight_initializer(self):\\n for m in self.modules():\\n if isinstance(m, nn.ConvTranspose2d):\\n nn.init.kaiming_normal_(m.weight)\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1.0)\\n nn.init.constant_(m.bias, 0.0)\",\n \"def init_parameters(self):\\n stdv = 1. / math.sqrt(self.weight.data.size(1))\\n self.weight.data.uniform_(-stdv, stdv)\\n if self.bias is not None:\\n self.bias.data.uniform_(-stdv, stdv)\",\n \"def __init__(self, embed_size):\\n super(EncoderCNN, self).__init__()\\n resnet = models.resnet152(pretrained=True)\\n modules = list(resnet.children())[:-1] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\\n self.init_weights()\",\n \"def init_layer(layer):\\n \\n if layer.weight.ndimension() == 4:\\n (n_out, n_in, height, width) = layer.weight.size()\\n n = n_in * height * width\\n \\n elif layer.weight.ndimension() == 2:\\n (n_out, n) = layer.weight.size()\\n\\n std = math.sqrt(2. / n)\\n scale = std * math.sqrt(3.)\\n layer.weight.data.uniform_(-scale, scale)\\n\\n if layer.bias is not None:\\n layer.bias.data.fill_(0.)\",\n \"def init_embedding_weights(self, dictionary, embeddings_index, embedding_dim):\\r\\n pretrained_weight = np.empty([len(dictionary), embedding_dim], dtype=float)\\r\\n for i in range(len(dictionary)):\\r\\n if dictionary.idx2word[i] in embeddings_index:\\r\\n pretrained_weight[i] = embeddings_index[dictionary.idx2word[i]]\\r\\n else:\\r\\n pretrained_weight[i] = helper.initialize_out_of_vocab_words(embedding_dim)\\r\\n # pretrained_weight is a numpy matrix of shape (num_embeddings, embedding_dim)\\r\\n if isinstance(self.embedding, nn.Sequential):\\r\\n self.embedding[0].weight.data.copy_(torch.from_numpy(pretrained_weight))\\r\\n else:\\r\\n self.embedding.weight.data.copy_(torch.from_numpy(pretrained_weight))\",\n \"def setWeightInitializer(self,weights):\\n self.init_w = weights\",\n \"def initialize_weights(self):\\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\\n return w1, w2\",\n \"def init_embedding(embeddings):\\n bias = np.sqrt(3.0 / embeddings.size(1))\\n torch.nn.init.uniform_(embeddings, -bias, bias)\",\n \"def _init_weights(self):\\n nn.init.xavier_normal_(self.out.weight)\",\n \"def init_weights(self):\\n for m in self.cls_convs:\\n normal_init(m.conv, std=0.01)\\n for m in self.reg_convs:\\n normal_init(m.conv, std=0.01)\\n normal_init(self.atss_reg, std=0.01)\\n normal_init(self.atss_iou, std=0.01)\\n bias_cls = bias_init_with_prob(0.01)\\n normal_init(self.atss_cls, std=0.01, bias=bias_cls)\",\n \"def init_weights(self):\\n if self.init_cfg:\\n super().init_weights()\\n else:\\n # Use smaller std for better stability and performance. We\\n # use 0.1. See more details in \\\"ESRGAN: Enhanced Super-Resolution\\n # Generative Adversarial Networks\\\"\\n for m in [\\n self.conv_first, self.conv_body, self.conv_up1,\\n self.conv_up2, self.conv_hr, self.conv_last\\n ]:\\n default_init_weights(m, 0.1)\",\n \"def init_weights(self):\\n\\n super().init_weights()\\n\\n init_type = None if self.init_cfg is None else self.init_cfg.get(\\n 'type', None)\\n if init_type != 'Pretrained' and self.with_tsa:\\n for module in [\\n self.fusion.feat_fusion, self.fusion.spatial_attn1,\\n self.fusion.spatial_attn2, self.fusion.spatial_attn3,\\n self.fusion.spatial_attn4, self.fusion.spatial_attn_l1,\\n self.fusion.spatial_attn_l2, self.fusion.spatial_attn_l3,\\n self.fusion.spatial_attn_add1\\n ]:\\n kaiming_init(\\n module.conv,\\n a=0.1,\\n mode='fan_out',\\n nonlinearity='leaky_relu',\\n bias=0,\\n distribution='uniform')\",\n \"def init_weights(model):\\n ...\",\n \"def init_weights(self, init_w=3e-3):\\n self.mean_linear.weight.data.uniform_(-init_w, init_w)\\n self.mean_linear.bias.data.uniform_(-init_w, init_w)\\n self.log_std_linear.weight.data.uniform_(-init_w, init_w)\\n self.log_std_linear.bias.data.uniform_(-init_w, init_w)\",\n \"def initialisation(self):\\n self.create_variables()\\n self.create_placeholders()\\n self.build_model()\\n self.reset_lr(None, True)\\n self.build_loss()\\n self.initialised = True\",\n \"def _init_weights(self):\\n for m in self.modules():\\n if type(m) in {\\n nn.Linear,\\n nn.Conv3d,\\n nn.Conv2d,\\n nn.ConvTranspose2d,\\n nn.ConvTranspose3d\\n }:\\n nn.init.kaiming_normal_(\\n m.weight.data, a=0, mode='fan_out', nonlinearity='relu',\\n )\\n if m.bias is not None:\\n fan_in, fan_out = \\\\\\n nn.init._calculate_fan_in_and_fan_out(m.weight.data)\\n bound = 1 / math.sqrt(fan_out)\\n nn.init.normal_(m.bias, -bound, bound)\",\n \"def _initialize_parameters(self):\\n self.ent_emb = tf.get_variable('ent_emb', shape=[len(self.ent_to_idx), self.k * 2],\\n initializer=self.initializer)\\n self.rel_emb = tf.get_variable('rel_emb', shape=[len(self.rel_to_idx), self.k * 2],\\n initializer=self.initializer)\",\n \"def __init__(self, embed_size):\\n super(EncoderCNN, self).__init__()\\n resnet = models.resnet152(pretrained=True)\\n modules = list(resnet.children())[:-1] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n self.pooling = nn.MaxPool2d(2,stride = 2)\\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\\n self.init_weights()\",\n \"def __init__(self, layer_id,\\n shape, X):\\n prefix = 'Embedding' + layer_id\\n self.n_words, self.in_size = shape\\n\\n # weights for embedding, the only parameters\\n self.W = init_weights(shape=(self.n_words, self.in_size),\\n name=prefix + '#W')\\n\\n self.params = [self.W]\\n\\n # Compute the embedded samples\\n self.n_timesteps = X.shape[0]\\n self.n_samples = X.shape[1]\\n\\n self.activation = self.W[X.flatten()].reshape([self.n_timesteps,\\n self.n_samples,\\n self.in_size])\",\n \"def init_weights(self):\\n r = np.sqrt(6.) / np.sqrt(self.fc1.in_features +\\n self.fc1.out_features)\\n self.fc1.weight.data.uniform_(-r, r)\\n self.fc1.bias.data.fill_(0)\\n r = np.sqrt(6.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\",\n \"def init_weights(layer):\\r\\n layer_name = layer.__class__.__name__\\r\\n if layer_name.find(\\\"Conv\\\") != -1:\\r\\n layer.weight.data.normal_(0.0, 0.02)\\r\\n elif layer_name.find(\\\"BatchNorm\\\") != -1:\\r\\n layer.weight.data.normal_(1.0, 0.02)\\r\\n layer.bias.data.fill_(0)\",\n \"def _initialize_parameters(self):\\n self.ent_emb = tf.get_variable('ent_emb', shape=[len(self.ent_to_idx), self.k],\\n initializer=self.initializer)\\n self.rel_emb = tf.get_variable('rel_emb', shape=[len(self.rel_to_idx), self.k],\\n initializer=self.initializer)\",\n \"def init_weights(self, dims):\\n self.W = np.random.normal(size=dims) * 0.0001\",\n \"def init_weights(self):\\r\\n constant_init(self.sampling_offsets, 0.)\\r\\n thetas = torch.arange(\\r\\n self.num_heads,\\r\\n dtype=torch.float32) * (2.0 * math.pi / self.num_heads)\\r\\n grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)\\r\\n grid_init = (grid_init /\\r\\n grid_init.abs().max(-1, keepdim=True)[0]).view(\\r\\n self.num_heads, 1, 1,\\r\\n 2).repeat(1, self.num_levels, self.num_points, 1)\\r\\n for i in range(self.num_points):\\r\\n grid_init[:, :, i, :] *= i + 1\\r\\n\\r\\n self.sampling_offsets.bias.data = grid_init.view(-1)\\r\\n constant_init(self.attention_weights, val=0., bias=0.)\\r\\n xavier_init(self.value_proj, distribution='uniform', bias=0.)\\r\\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\\r\\n self._is_init = True\",\n \"def __init__(self, input_dim, output_dim, name='embedding_layer'):\\n self.input_dim = input_dim\\n self.output_dim = output_dim\\n self.name = name\\n\\n # Randomly generate weights\\n self.embeddings = shared((input_dim, output_dim),\\n self.name + '__embeddings')\\n\\n # Define parameters\\n self.params = [self.embeddings]\",\n \"def _init_layers(self):\\n self._init_predictor()\\n if self.use_edge_fusion:\\n self._init_edge_module()\",\n \"def initialize_weights(self, input_dim, std_dev=1e-2):\\n \\n self.params = {}\\n\\n hidden_size = self.hidden_size\\n num_classes = self.num_classes\\n num_layers = self.num_layers\\n #############################################################################\\n # TODO: Initialize the weight and bias of every layer. Store the weights W #\\n # of every layer in the dictionary names self.params. #\\n # For example, Weights and bias of layer 1 will be stored in #\\n # self.params[\\\"W1\\\"] and self.params[\\\"b1\\\"] respectively. #\\n #############################################################################\\n # input_dim * hidden_size\\n self.params[\\\"W1\\\"] = np.random.randn(input_dim, self.hidden_size) * std_dev\\n self.params[\\\"b1\\\"] = np.zeros(self.hidden_size)\\n\\n # hidden_size * num_classes\\n self.params[\\\"W2\\\"] = np.random.randn(self.hidden_size, self.num_classes) * std_dev\\n self.params[\\\"b2\\\"] = np.zeros(self.num_classes)\\n #############################################################################\\n # END OF YOUR CODE #\\n ############################################################################# \",\n \"def _initialize_weights(self):\\r\\n for m in self.modules():\\r\\n if isinstance(m, nn.Conv2d):\\r\\n m.weight.data.normal_(0, 0.05)\\r\\n if m.bias is not None:\\r\\n m.bias.data.zero_()\",\n \"def init_weights(self, pretrained):\\n if self.with_shared_head:\\n self.shared_head.init_weights(pretrained=pretrained)\\n for i in range(1):\\n if self.with_bbox:\\n self.bbox_roi_extractor[i].init_weights()\\n self.bbox_head[i].init_weights()\\n if self.with_rbbox:\\n self.rbbox_roi_extractor[i].init_weights()\\n self.rbbox_head[i].init_weights()\\n if self.with_mask:\\n if not self.share_roi_extractor:\\n self.mask_roi_extractor[i].init_weights()\\n self.mask_head[i].init_weights()\",\n \"def init_weights(self):\\n\\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\\n self.fc3.out_features)\\n self.fc3.weight.data.uniform_(-r, r)\\n self.fc3.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc1.in_features +\\n self.fc1.out_features)\\n self.fc1.weight.data.uniform_(-r, r)\\n self.fc1.bias.data.fill_(0)\",\n \"def initialize_model(self):\\n\\n input_layer = Input(\\n shape=(self.input_length,), \\n dtype='int32', \\n name='input'\\n )\\n\\n if self.embedding_matrix is None:\\n embedding = Embedding(\\n output_dim=self.embedding_size,\\n input_dim=self.vocabulary_size + 1, # for mask\\n input_length=self.input_length,\\n mask_zero=True,\\n name='embedding'\\n )(input_layer)\\n else:\\n embedding = Embedding(\\n output_dim=self.embedding_size,\\n input_dim=self.vocabulary_size + 1,\\n input_length=self.input_length,\\n mask_zero=True,\\n weights=[np.vstack((np.zeros((1, self.embedding_size)),\\n self.embedding_matrix))],\\n name='embedding'\\n )(input_layer)\\n\\n encoder = self.recurrent_cell(\\n self.latent_dim,\\n dropout=self.dropout,\\n recurrent_dropout=self.dropout,\\n name='encoder',\\n recurrent_regularizer=l1_l2(*self.regularization)\\n )\\n\\n if self.use_bidirection:\\n encoder = Bidirectional(\\n encoder,\\n merge_mode='concat'\\n )\\n\\n encoder = encoder(embedding)\\n\\n dense_1 = Dense(\\n 1024,\\n activation='tanh',\\n name='dense_1',\\n kernel_regularizer=l1_l2(*self.regularization)\\n )(encoder)\\n\\n dense_2 = Dense(\\n 512,\\n activation='tanh',\\n name='dense_2',\\n kernel_regularizer=l1_l2(*self.regularization)\\n )(dense_1)\\n\\n dropout = Dropout(self.dropout)(\\n dense_2\\n )\\n\\n prediction = Dense(\\n 1,\\n activation='sigmoid',\\n name='prediction'\\n )(dropout)\\n\\n model = Model(inputs=input_layer, outputs=prediction)\\n\\n # sparse_categorical_crossentropy\\n model.compile(optimizer=Adam(lr=self.learning_rate),\\n loss='binary_crossentropy',\\n metrics=['acc'])\\n\\n self.model = model\\n\\n if self.verbose > 0:\\n model.summary()\\n\\n return [model]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77943677","0.7777627","0.76114255","0.76029295","0.7508789","0.7387998","0.73835915","0.73677576","0.73591816","0.73591816","0.73591816","0.73556024","0.73530215","0.72580236","0.72257406","0.71798956","0.71372914","0.71090186","0.7084901","0.70644426","0.70416605","0.70236707","0.70066327","0.69914776","0.6990578","0.6985493","0.69583356","0.6945526","0.6936313","0.69355106","0.69216424","0.6912922","0.6910844","0.690093","0.69008964","0.6890882","0.68823564","0.6876674","0.6872653","0.68632287","0.6860331","0.68597126","0.68551207","0.6848497","0.68134207","0.6808225","0.6799514","0.6791836","0.6781607","0.67814183","0.6776232","0.6776232","0.6776232","0.67499447","0.67499447","0.6746704","0.67281413","0.67129","0.6678633","0.6659197","0.6657682","0.66418946","0.66333485","0.66289055","0.6626829","0.6626508","0.66202074","0.6606386","0.65983033","0.6579713","0.6575429","0.6574142","0.6571882","0.65717655","0.65660816","0.6562321","0.655595","0.65537673","0.6551371","0.65464026","0.6544105","0.65298325","0.65220016","0.6514276","0.65124196","0.6505711","0.6496255","0.64799476","0.6478733","0.64785326","0.6477273","0.6476786","0.64702183","0.646305","0.64601266","0.6456845","0.6451055","0.6448288","0.64444214","0.6432571"],"string":"[\n \"0.77943677\",\n \"0.7777627\",\n \"0.76114255\",\n \"0.76029295\",\n \"0.7508789\",\n \"0.7387998\",\n \"0.73835915\",\n \"0.73677576\",\n \"0.73591816\",\n \"0.73591816\",\n \"0.73591816\",\n \"0.73556024\",\n \"0.73530215\",\n \"0.72580236\",\n \"0.72257406\",\n \"0.71798956\",\n \"0.71372914\",\n \"0.71090186\",\n \"0.7084901\",\n \"0.70644426\",\n \"0.70416605\",\n \"0.70236707\",\n \"0.70066327\",\n \"0.69914776\",\n \"0.6990578\",\n \"0.6985493\",\n \"0.69583356\",\n \"0.6945526\",\n \"0.6936313\",\n \"0.69355106\",\n \"0.69216424\",\n \"0.6912922\",\n \"0.6910844\",\n \"0.690093\",\n \"0.69008964\",\n \"0.6890882\",\n \"0.68823564\",\n \"0.6876674\",\n \"0.6872653\",\n \"0.68632287\",\n \"0.6860331\",\n \"0.68597126\",\n \"0.68551207\",\n \"0.6848497\",\n \"0.68134207\",\n \"0.6808225\",\n \"0.6799514\",\n \"0.6791836\",\n \"0.6781607\",\n \"0.67814183\",\n \"0.6776232\",\n \"0.6776232\",\n \"0.6776232\",\n \"0.67499447\",\n \"0.67499447\",\n \"0.6746704\",\n \"0.67281413\",\n \"0.67129\",\n \"0.6678633\",\n \"0.6659197\",\n \"0.6657682\",\n \"0.66418946\",\n \"0.66333485\",\n \"0.66289055\",\n \"0.6626829\",\n \"0.6626508\",\n \"0.66202074\",\n \"0.6606386\",\n \"0.65983033\",\n \"0.6579713\",\n \"0.6575429\",\n \"0.6574142\",\n \"0.6571882\",\n \"0.65717655\",\n \"0.65660816\",\n \"0.6562321\",\n \"0.655595\",\n \"0.65537673\",\n \"0.6551371\",\n \"0.65464026\",\n \"0.6544105\",\n \"0.65298325\",\n \"0.65220016\",\n \"0.6514276\",\n \"0.65124196\",\n \"0.6505711\",\n \"0.6496255\",\n \"0.64799476\",\n \"0.6478733\",\n \"0.64785326\",\n \"0.6477273\",\n \"0.6476786\",\n \"0.64702183\",\n \"0.646305\",\n \"0.64601266\",\n \"0.6456845\",\n \"0.6451055\",\n \"0.6448288\",\n \"0.64444214\",\n \"0.6432571\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66120446"},"document_rank":{"kind":"string","value":"67"}}},{"rowIdx":82994,"cells":{"query":{"kind":"string","value":"Initialises weights of a given parameter following either Xavier or Kaiming uniform or normal processes."},"document":{"kind":"string","value":"def initialise_process(param):\n \n if self._initialisation_process == 'xavier_uniform':\n tnni.xavier_uniform_(param.data)\n elif self._initialisation_process == 'xavier_normal':\n tnni.xavier_normal_(param.data)\n elif self._initialisation_process == 'kaiming_uniform':\n tnni.kaiming_uniform_(param.data)\n elif self._initialisation_process == 'kaiming_normal':\n tnni.kaiming_normal_(param.data)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def init_weight(self):\r\n xavier_init(self.output_proj, distribution='uniform', bias=0.)","def init_weights_(self):\n raise NotImplementedError","def initialise_weights(self): \n \n def initialise_process(param):\n \n \"\"\"\n Initialises weights of a given parameter following either Xavier or Kaiming uniform or normal processes.\n \n : param (torch.Tensor):\n \n \"\"\"\n \n if self._initialisation_process == 'xavier_uniform':\n tnni.xavier_uniform_(param.data)\n elif self._initialisation_process == 'xavier_normal':\n tnni.xavier_normal_(param.data)\n elif self._initialisation_process == 'kaiming_uniform':\n tnni.kaiming_uniform_(param.data)\n elif self._initialisation_process == 'kaiming_normal':\n tnni.kaiming_normal_(param.data)\n \n if self._initialisation_process is not None:\n for m in self.modules():\n # Embedding\n if type(m) is nn.Embedding:\n tnni.normal_(self.embedding.weight)\n # RNN\n elif type(m) in [nn.GRU, nn.LSTM, nn.RNN]: \n for name, param in m.named_parameters():\n if 'weight_ih' in name:\n initialise_process(param)\n #torch.nn.init.kaiming_normal_(param.data)\n elif 'weight_hh' in name:\n tnni.orthogonal_(param.data)\n elif 'bias' in name:\n # Bias initialised with zero will get the bias from\n # the forget gate\n param.data.fill_(0.0)\n param.data[self._hidden_size:self.directions*self._hidden_size].fill_(1.0)\n # Attention linear layer\n elif type(m) is nn.Linear:\n for name, param in m.named_parameters():\n if 'weight' in name:\n initialise_process(param.data)\n elif 'bias' in name:\n param.data.normal_()","def _init_weights(self):\n nn.init.xavier_normal_(self.out.weight)","def init_parameters(self):\n stdv = 1. / math.sqrt(self.weight.data.size(1))\n self.weight.data.uniform_(-stdv, stdv)\n if self.bias is not None:\n self.bias.data.uniform_(-stdv, stdv)","def init_weights(self) -> None:\n nn.init.kaiming_normal_(self._U)\n nn.init.kaiming_normal_(self._W)\n nn.init.kaiming_normal_(self._V)\n\n nn.init.normal_(self._b)","def initialize_weights_xavier(self):\n\t\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\n\t\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]","def reset_parameters(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)\n if self.xl_like:\n nn.init.xavier_uniform_(self.w_pos.weight)\n if bias:\n nn.init.constant_(self.w_pos.bias, 0.0)","def init_weights(self):\n \n self.w = np.random.randn(self.D) / np.sqrt(self.D)","def init_weights(model):\n ...","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)\n # Tie weights if needed\n self.tie_weights()","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)","def reset_parameters(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)","def reset_parameters(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)","def init_weights(self, dims):\n self.W = np.random.normal(size=dims) * 0.0001","def reset_parameters_xavier_uniform(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n if self.conv1d is not None:\n for n, p in self.conv1d.named_parameters():\n init_with_xavier_uniform(n, p)","def InitWeights(self):\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\n self.w0 = -1 + 2 * np.random.rand()","def _initialize_weights(self):\n pass","def reset_parameters_xavier_uniform(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)","def reset_parameters_xavier_uniform(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)","def setWeightInitializer(self,weights):\n self.init_w = weights","def init_weights(self, init_w=3e-3):\n self.mean_linear.weight.data.uniform_(-init_w, init_w)\n self.mean_linear.bias.data.uniform_(-init_w, init_w)\n self.log_std_linear.weight.data.uniform_(-init_w, init_w)\n self.log_std_linear.bias.data.uniform_(-init_w, init_w)","def XavierInit(self):\n\n raw_std = (2 / (self.num_input + self.num_output))**0.5\n if 'relu' == self.act_function:\n init_std = raw_std * (2**0.5)\n elif 'sigmoid' == self.act_function:\n init_std = raw_std\n else:\n init_std = raw_std # * 4\n\n self.W = np.random.normal(0, init_std, (self.num_input, self.num_output))\n self.b = np.random.normal(0, init_std, (1, self.num_output))\n self.v_W = 0\n self.v_b = 0","def weights_initializer(self):\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]","def init_weight(w):\n shape = w.shape\n if len(shape) == 4:\n i, o, u, v = shape\n k = np.sqrt(6 / (i * u * v + o * u * v))\n w.data.uniform_(-k, k)\n elif len(shape) == 2:\n k = np.sqrt(6 / sum(shape))\n w.data.uniform_(-k, k)\n elif len(shape) == 1:\n w.data.zero_()","def _init_weights(self):\n for layer in self.modules():\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\n nn.init.xavier_uniform_(layer.weight)\n if layer.bias is not None:\n nn.init.constant_(layer.bias, 0)\n elif isinstance(layer, nn.BatchNorm1d):\n nn.init.constant_(layer.weight, 1)\n nn.init.constant_(layer.bias, 0)","def _init_weights(self):\n for layer in self.modules():\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\n nn.init.xavier_uniform_(layer.weight)\n if layer.bias is not None:\n nn.init.constant_(layer.bias, 0)\n elif isinstance(layer, nn.BatchNorm1d):\n nn.init.constant_(layer.weight, 1)\n nn.init.constant_(layer.bias, 0)","def _init_weights(self):\n for layer in self.modules():\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\n nn.init.xavier_uniform_(layer.weight)\n if layer.bias is not None:\n nn.init.constant_(layer.bias, 0)\n elif isinstance(layer, nn.BatchNorm1d):\n nn.init.constant_(layer.weight, 1)\n nn.init.constant_(layer.bias, 0)","def init_weight(self):\n init_bn(self.norm0)","def initialize_weights(model: nn.Module, transformer: bool = False) -> None:\n for param in model.parameters():\n if param.dim() == 1:\n if transformer:\n nn.init.constant_(param, 0.01)\n else:\n nn.init.constant_(param, 0)\n else:\n nn.init.xavier_normal_(param)","def _weight_initializer(self):\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n nn.init.kaiming_normal_(m.weight)\n elif isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1.0)\n nn.init.constant_(m.bias, 0.0)","def default_weight_initializer(self):\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]","def weights_init(m):\n if (\n isinstance(m, nn.Linear)\n or isinstance(m, nn.EmbeddingBag)\n or isinstance(m, nn.Embedding)\n or isinstance(m, SparseLinear)\n ):\n nn.init.xavier_normal_(m.weight)","def _weight_initializer(self):\n for m in self.modules():\n if isinstance(m, nn.ConvTranspose2d):\n nn.init.kaiming_normal_(m.weight)\n elif isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1.0)\n nn.init.constant_(m.bias, 0.0)","def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):\n\n self.params = {}\n self.params['W1'] = weight_init_std * \\\n np.random.randn(input_size, hidden_size)\n self.params['b1'] = np.zeros(hidden_size)\n self.params['W2'] = weight_init_std * \\\n np.random.randn(hidden_size, output_size)\n self.params['b2'] = np.zeros(output_size)","def get_weights(fs, W_init=None, std_scale=0.4):\n\n if W_init == None:\n stddev = std_scale*np.sqrt(2.0 / np.prod(fs[:3]))\n W_init = torch.normal(torch.zeros(*fs), stddev)\n\n W_init = nn.Parameter(W_init) \n return W_init","def init_weights(self, init_w=3e-3):\n self.l3.weight.data.uniform_(-init_w, init_w)\n self.l3.bias.data.uniform_(-init_w, init_w)","def init_weights(self, init_w=3e-3):\n self.l3.weight.data.uniform_(-init_w, init_w)\n self.l3.bias.data.uniform_(-init_w, init_w)","def init_weights(m):\n\tif type(m) == nn.Linear:\n\t\ttorch.nn.init.xavier_normal(m.weight)\n\t\tm.bias.data.fill_(0.01)","def weight_initialization(m: nn.Module) -> None:\n if type(m) == nn.Linear:\n # nn.init.xavier_uniform_(m.weight, np.sqrt(2.)) # gain is sqrt(2) because we use ReLU\n nn.init.kaiming_uniform_(m.weight, a=np.sqrt(5))\n # nn.init.uniform(m.weight, 0., 0.)","def my_assign_weights(context, data):\n pass","def reset_parameters_xavier_uniform(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for n, p in self.named_parameters():\n init_with_xavier_uniform(n, p)","def reset_parameters_xavier_uniform(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for n, p in self.named_parameters():\n init_with_xavier_uniform(n, p)","def init_weights(self):\r\n constant_init(self.sampling_offsets, 0.)\r\n thetas = torch.arange(\r\n self.num_heads,\r\n dtype=torch.float32) * (2.0 * math.pi / self.num_heads)\r\n grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)\r\n grid_init = (grid_init /\r\n grid_init.abs().max(-1, keepdim=True)[0]).view(\r\n self.num_heads, 1, 1,\r\n 2).repeat(1, self.num_levels, self.num_points, 1)\r\n for i in range(self.num_points):\r\n grid_init[:, :, i, :] *= i + 1\r\n\r\n self.sampling_offsets.bias.data = grid_init.view(-1)\r\n constant_init(self.attention_weights, val=0., bias=0.)\r\n xavier_init(self.value_proj, distribution='uniform', bias=0.)\r\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\r\n self._is_init = True","def WeightInitializer():\n return np.random.uniform(-1, 1)","def init_weights(self, load_weights=None):\n if load_weights:\n # TODO\n pass\n else:\n # x: lower layer nodes n\n # y: current layer nodes n\n x = self.weights_shape[1]\n y = self.weights_shape[0]\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member","def init_weights(n_input_layer, n_hidden_layer, n_hidden_layer_2, n_output_layer, xavier_init):\n W1, W2, W3 = None, None, None\n \n if xavier_init: # Checks if Xavier initialisation is wanted\n # Initialises weights depending on number of layers present using:\n # Normally distributed random number * square_root(1 / number of input neurons to that layer)\n if n_hidden_layer > 0:\n W1 = np.random.randn(n_hidden_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\n\n if n_hidden_layer_2 > 0:\n W2 = np.random.randn(n_hidden_layer_2, n_hidden_layer) * np.sqrt(1 / (n_hidden_layer))\n W3 = np.random.randn(n_output_layer, n_hidden_layer_2) * np.sqrt(1 / (n_hidden_layer_2))\n\n else:\n W2 = np.random.randn(n_output_layer, n_hidden_layer) * np.sqrt(1 / (n_hidden_layer))\n\n else:\n W1 = np.random.randn(n_output_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\n\n else:\n # Weights are randomly picked from a uniform distribution between 0 and 1\n # They are normalized by making sure the weights sum to 1\n # Uses different configurations depending on number of layers required\n if n_hidden_layer > 0:\n W1 = np.random.uniform(0,1,(n_hidden_layer, n_input_layer))\n W1 = np.divide(W1,np.matlib.repmat(np.sum(W1,1)[:,None],1,n_input_layer))\n \n if n_hidden_layer_2 > 0:\n W2=np.random.uniform(0,1,(n_hidden_layer_2,n_hidden_layer))\n W2=np.divide(W2,np.matlib.repmat(np.sum(W2,1)[:,None],1,n_hidden_layer))\n\n W3=np.random.uniform(0,1,(n_output_layer,n_hidden_layer_2))\n W3=np.divide(W3,np.matlib.repmat(np.sum(W3,1)[:,None],1,n_hidden_layer_2))\n\n else:\n W2 = np.random.uniform(0,1,(n_output_layer, n_hidden_layer))\n W2 = np.divide(W2,np.matlib.repmat(np.sum(W2,1)[:,None],1,n_hidden_layer))\n\n else:\n W1 = np.random.randn(n_output_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\n\n return W1, W2, W3","def Winit(Weightinit):\n\n DicWinit = {'LecunNormal':tf.keras.initializers.lecun_normal(seed=None),\n 'LecunUniform':tf.keras.initializers.lecun_uniform(seed=None),\n 'GlorotNormal':tf.keras.initializers.GlorotNormal(seed=None),\n 'GlorotUniform':tf.keras.initializers.GlorotUniform(seed=None),\n 'HeNormal':tf.keras.initializers.he_normal(seed=None),\n 'HeUniform':tf.keras.initializers.he_uniform(seed=None)}\n return DicWinit[Weightinit]","def init_weights(self):\n for m in self.modules():\n if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):\n xavier_uniform_(m.weight)\n if m.bias is not None:\n zeros_(m.bias)","def reset_parameters(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for n, p in self.named_parameters():\n init_with_xavier_uniform(n, p)","def reset_parameters(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for n, p in self.named_parameters():\n init_with_xavier_uniform(n, p)","def _WeightInit(self, stddev):\n return init_ops.truncated_normal_initializer(stddev=stddev)","def init_weights(self, sizes, init, X, Y):\n\t\tinit = init.lower()\n\n\t\tif init == 'none':\n\t\t\tpass\n\t\telif init == 'zeros':\n\t\t\tself.wts = arr([np.zeros((sizes[i + 1],sizes[i] + 1)) for i in range(len(sizes) - 1)], dtype=object)\n\t\telif init == 'random':\n\t\t\tself.wts = arr([.0025 * np.random.randn(sizes[i+1],sizes[i]+1) for i in range(len(sizes) - 1)], dtype=object)\n\t\telse:\n\t\t\traise ValueError('NNetClassify.init_weights: ' + str(init) + ' is not a valid option for init')","def reset_parameters_xavier_uniform(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for conv_layer in [self.pointwise_conv1, self.pointwise_conv2, self.depthwise_conv]:\n for n, p in conv_layer.named_parameters():\n init_with_xavier_uniform(n, p)","def init_weights(self) -> None:\n super().init_weights()\n kaiming_init(self.convs_all_levels, a=1, distribution='uniform')\n kaiming_init(self.conv_branch, a=1, distribution='uniform')\n kaiming_init(self.conv_pred, a=1, distribution='uniform')","def init_weights(m):\n if isinstance(m, nn.Linear):\n nn.init.normal_(m.weight, mean=0.1, std=0.01)\n nn.init.constant_(m.bias, 0.0)","def init_weights(self):\n if self.init_cfg:\n super().init_weights()\n else:\n # Use smaller std for better stability and performance. We\n # use 0.1. See more details in \"ESRGAN: Enhanced Super-Resolution\n # Generative Adversarial Networks\"\n for m in [\n self.conv_first, self.conv_body, self.conv_up1,\n self.conv_up2, self.conv_hr, self.conv_last\n ]:\n default_init_weights(m, 0.1)","def _random_weight_initialization(self, mean=0, stddev=1):\n self.slp_weights = np.random.normal(mean, stddev, size=(self.n_rbfs, self.n_targets))","def init_params_weight(row,column):\n W = np.random.rand(row, column)\n W = W*2.0-1.0\n return W.astype(config.floatX) # @UndefinedVariable","def initialize_weights(self):\n weights_initializer.WeightsInitializer.initialize_layer_or_model(\n self._batch)","def init_weights(self):\n for i in range(5):\n default_init_weights(getattr(self, f'conv{i+1}'), 0.1)","def init_weights(self):\n if isinstance(self.pretrained, str):\n logger = get_root_logger()\n logger.info(f'load model from: {self.pretrained}')\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\n elif self.pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n xavier_init(m, distribution='uniform')\n elif isinstance(m, nn.Linear):\n normal_init(m, std=0.01)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self):\r\n self.embedding.weight.data.uniform_(-0.1, 0.1)\r\n self.fc.bias.data.fill_(0)\r\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self):\n if isinstance(self.pretrained, str):\n logger = get_root_logger()\n logger.info(f'load model from: {self.pretrained}')\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\n elif self.pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n xavier_init(m, distribution='uniform')\n elif isinstance(m, nn.Linear):\n normal_init(m, std=0.01)\n elif isinstance(m, nn.BatchNorm2d):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def ComputeWeights(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\n ...","def init_weights(self):\n self._q_neuron.h(self._weights) \n self._q_neuron.x(self._weights)","def init_weights(self):\n for m in self.cls_convs:\n normal_init(m.conv, std=0.01)\n for m in self.reg_convs:\n normal_init(m.conv, std=0.01)\n normal_init(self.atss_reg, std=0.01)\n normal_init(self.atss_iou, std=0.01)\n bias_cls = bias_init_with_prob(0.01)\n normal_init(self.atss_cls, std=0.01, bias=bias_cls)","def __init__(self, alpha, weights):\n self._weights = weights\n self._alpha = alpha","def reset_parameters(self):\n if self.W is not None:\n tanh_gain = weight_init.calculate_gain(\"tanh\")\n weight_init.xavier_normal_(self.W, tanh_gain)\n # self.W.data.uniform_(-0.001, 0.001)","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self) -> None:\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def __init__(self, weights):\n self._weights = weights","def initialize_weights(m):\n if isinstance(m, nn.Linear) or isinstance(m, nn.ConvTranspose2d):\n init.xavier_uniform(m.weight.data)","def __init__(self, size, parameters):\n\n self.weights = self.init_weights(size)\n self.alpha = parameters['alpha']\n self.epsilon = parameters['epsilon']\n self.gamma = parameters['gamma']\n self.value = 0.0 #np.random.random()","def _initialize_weights(self, inputs):\n if self.data_init:\n self._data_dep_init(inputs)\n else:\n self._init_norm()\n self._initialized = True","def _init_weights(module: nn.Module, name: str, head_bias: float = 0., flax=False):\n if isinstance(module, nn.Linear):\n if name.startswith('head'):\n nn.init.zeros_(module.weight)\n nn.init.constant_(module.bias, head_bias)\n else:\n if flax:\n # Flax defaults\n lecun_normal_(module.weight)\n if module.bias is not None:\n nn.init.zeros_(module.bias)\n else:\n # like MLP init in vit (my original init)\n nn.init.xavier_uniform_(module.weight)\n if module.bias is not None:\n if 'mlp' in name:\n nn.init.normal_(module.bias, std=1e-6)\n else:\n nn.init.zeros_(module.bias)\n elif isinstance(module, nn.Conv2d):\n lecun_normal_(module.weight)\n if module.bias is not None:\n nn.init.zeros_(module.bias)\n elif isinstance(module, (nn.LayerNorm, nn.BatchNorm2d, nn.GroupNorm)):\n nn.init.ones_(module.weight)\n nn.init.zeros_(module.bias)\n elif hasattr(module, 'init_weights'):\n # NOTE if a parent module contains init_weights method, it can override the init of the\n # child modules as this will be called in depth-first order.\n module.init_weights()","def default_weights(n):\n return np.array([1/n for _ in range(n)])","def init_weights(no_input, no_hidden, no_output):\r\n weight_lst = []\r\n no_of_weights = (no_input * no_hidden) + (no_hidden * no_output)\r\n\r\n for weight in range(no_of_weights):\r\n weight = 0.01 * random.random()\r\n weight_lst.append(weight)\r\n\r\n return weight_lst","def xavier_uniform(self, weight, activation):\n if activation == 'none':\n nn.init.xavier_uniform(weight, gain=layers.gain(activation))\n elif activation == 'sigmoid':\n nn.init.xavier_uniform(weight, gain=layers.gain(activation))\n elif activation == 'tanh':\n nn.init.xavier_uniform(weight, gain=layers.gain(activation))\n elif activation == 'relu':\n nn.init.xavier_uniform(weight, gain=layers.gain(activation))","def init_weights(self):\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\n self.fc.out_features)\n self.fc.weight.data.uniform_(-r, r)\n self.fc.bias.data.fill_(0)","def init_weights(self):\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\n self.fc.out_features)\n self.fc.weight.data.uniform_(-r, r)\n self.fc.bias.data.fill_(0)","def init_weights(self, leveledinit: bool, kernel_size: int, bias: bool) -> None:\n if leveledinit:\n nn.init.normal_(self.conv1d.weight, std=1e-3)\n nn.init.normal_(self.conv1d.bias, std=1e-6)\n with torch.no_grad():\n self.conv1d.weight[:, 0, :] += 1.0 / kernel_size\n else:\n nn.init.xavier_uniform_(self.conv1d.weight)\n\n if self.embed in (\"pre\", \"post\"):\n nn.init.xavier_uniform_(self.embedding.weight)","def weights_init(m):\n if type(m) == torch.nn.Linear:\n m.weight.data.normal_(0.0, 0.02)\n m.bias.data.fill_(0)","def initialize_weights(self):\n # compute lmda.\n self.lmda = float(self.c)/float(self.N)\n # bias term. This should not get a regularization penalty.\n self.bias = {}\n # weight vector\n self.w = {}\n # lastW[j] = k, indicates that feature j was last updated at time k.\n self.lastW = {}\n for lbl in self.labels:\n self.bias[lbl] = 0\n self.w[lbl] = {}\n self.lastW[lbl] = {}\n pass","def __init__(self, num_parameters=1, init=0.25):\n super(PReLU, self).__init__()\n self.num_parameters = num_parameters\n self.weight = Parameter(Tensor(num_parameters).fill_(init))","def initialize_weights(self, weights_initializer, bias_initializer):\n wshapes = [\n [self.input_size, self.hidden_size[0]],\n [self.hidden_size[0], self.hidden_size[1]],\n [self.hidden_size[1], self.output_size]\n ]\n\n bshapes = [\n [1, self.hidden_size[0]],\n [1, self.hidden_size[1]],\n [1, self.output_size]\n ]\n\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\n\n self.trainable_variables = self.weights + self.biases","def initialize_weights(training_points):\n N = len(training_points)\n ans = {}\n for p in training_points:\n ans[p] = make_fraction(1, N)\n return ans","def init_weight(self):\n init_layer(self.conv1)\n init_layer(self.conv2)\n init_bn(self.norm1)\n init_bn(self.norm2)","def init_weights(self, t, prior, scaled_prior = False):\n from scipy.cluster.vq import kmeans2\n from scipy.spatial.distance import cdist\n \n # check if t has the right shape\n if not t.ndim == 2:\n t = t[:, None]\n \n if scaled_prior:\n #self.w1 = np.random.normal(loc=0.0, scale = 1,size=[H, d+1])/np.sqrt(d+1) # 1st layer weights + bias\n #self.w2 = np.random.normal(loc=0.0, scale = 1,size=[ny, H+1])/np.sqrt(H+1) # 2nd layer weights + bias\n sigma1 = 1.0/np.sqrt(self.d+1)\n sigma2 = 1.0/np.sqrt(self.H+1)\n else:\n # init weights from gaussian with width given by prior\n sigma1 = 1.0/np.sqrt(prior)\n sigma2 = sigma1\n \n self.w1 = np.random.normal(loc=0.0, scale = 1,size=[self.H, self.d+1]) * sigma1 # 1st layer weights + bias\n self.w2 = np.random.normal(loc=0.0, scale = 1,size=[self.ny, self.H+1]) * sigma2 # 2nd layer weights + bias\n \n # init biases (taken from netlab, gmminit.m)\n [centroid, label] = kmeans2(t, self.M)\n cluster_sizes = np.maximum(np.bincount(label), 1) # avoid empty clusters\n alpha = cluster_sizes/np.sum(cluster_sizes)\n if (self.M > 1):\n # estimate variance from the distance to the nearest centre\n sigma = cdist(centroid, centroid)\n sigma = np.min(sigma + np.diag(np.diag(np.ones(sigma.shape))) * 1000, 1)\n sigma = np.maximum(sigma, np.finfo(float).eps) # avoid underflow\n else:\n # only one centre: take average variance\n sigma = np.mean(np.diag([np.var(t)]))\n # set biases, taken from netlab, mdninit.m\n self.w2[0:self.M,0] = alpha\n self.w2[self.M:2*self.M,0] = np.log(sigma)\n self.w2[2*self.M:,0] = np.reshape(centroid, [self.M * self.c])","def xavier_init(module, gain=1, bias=0, distribution='normal'):\n # assert distribution in ['uniform', 'normal']\n if distribution == 'uniform':\n nn.init.xavier_uniform_(module.weight, gain=gain)\n else:\n nn.init.xavier_normal_(module.weight, gain=gain)\n if hasattr(module, 'bias') and module.bias is not None:\n nn.init.constant_(module.bias, bias)","def initWeights(self):\n self.weights = []\n self.bias = []\n for i, dim in enumerate(self.dimensions[1:]):\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\n self.bias.append(np.random.uniform(-1,1,dim))","def _initialize_weights(self, m):\n self.rgen = np.random.RandomState(self.random_state)\n self.w_ = self.rgen.normal(loc=0.0, scale=0.01, size=m)\n self.b_ = 0\n self.w_avg = self.rgen.normal(loc=0.0, scale=0.01, size=m)\n self.b_avg = 0\n\n def net_input(self, X):\n return np.dot(X, self.w_[1:]) + self.w_[0]\n\n def activation(self, X):\n return X\n \n def predict(self, X):\n return np.where(self.net_input(X) >= 0.0, 1, -1)\n \n def get_params(self, deep=True):\n return {\"eta\":self.eta, \"max_iter\":self.max_iter, \"C\":self.C, \"random_state\":self.random_state, \"batch_size\":self.batch_size}\n \n def set_params(self, **parameters):\n for parameter, value in parameters.items():\n setattr(self, parameters, value)\n return self","def set_weights(self, weights):\r\n self.weights = weights","def init_weights(self, pretrained=None):\n if pretrained is not None:\n self.pretrained = pretrained\n self.backbone.init_weights(self.pretrained)\n self.mesh_head.init_weights()\n if self.with_gan:\n self.discriminator.init_weights()"],"string":"[\n \"def init_weight(self):\\r\\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\",\n \"def init_weights_(self):\\n raise NotImplementedError\",\n \"def initialise_weights(self): \\n \\n def initialise_process(param):\\n \\n \\\"\\\"\\\"\\n Initialises weights of a given parameter following either Xavier or Kaiming uniform or normal processes.\\n \\n : param (torch.Tensor):\\n \\n \\\"\\\"\\\"\\n \\n if self._initialisation_process == 'xavier_uniform':\\n tnni.xavier_uniform_(param.data)\\n elif self._initialisation_process == 'xavier_normal':\\n tnni.xavier_normal_(param.data)\\n elif self._initialisation_process == 'kaiming_uniform':\\n tnni.kaiming_uniform_(param.data)\\n elif self._initialisation_process == 'kaiming_normal':\\n tnni.kaiming_normal_(param.data)\\n \\n if self._initialisation_process is not None:\\n for m in self.modules():\\n # Embedding\\n if type(m) is nn.Embedding:\\n tnni.normal_(self.embedding.weight)\\n # RNN\\n elif type(m) in [nn.GRU, nn.LSTM, nn.RNN]: \\n for name, param in m.named_parameters():\\n if 'weight_ih' in name:\\n initialise_process(param)\\n #torch.nn.init.kaiming_normal_(param.data)\\n elif 'weight_hh' in name:\\n tnni.orthogonal_(param.data)\\n elif 'bias' in name:\\n # Bias initialised with zero will get the bias from\\n # the forget gate\\n param.data.fill_(0.0)\\n param.data[self._hidden_size:self.directions*self._hidden_size].fill_(1.0)\\n # Attention linear layer\\n elif type(m) is nn.Linear:\\n for name, param in m.named_parameters():\\n if 'weight' in name:\\n initialise_process(param.data)\\n elif 'bias' in name:\\n param.data.normal_()\",\n \"def _init_weights(self):\\n nn.init.xavier_normal_(self.out.weight)\",\n \"def init_parameters(self):\\n stdv = 1. / math.sqrt(self.weight.data.size(1))\\n self.weight.data.uniform_(-stdv, stdv)\\n if self.bias is not None:\\n self.bias.data.uniform_(-stdv, stdv)\",\n \"def init_weights(self) -> None:\\n nn.init.kaiming_normal_(self._U)\\n nn.init.kaiming_normal_(self._W)\\n nn.init.kaiming_normal_(self._V)\\n\\n nn.init.normal_(self._b)\",\n \"def initialize_weights_xavier(self):\\n\\t\\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\\n\\t\\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]\",\n \"def reset_parameters(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\\n if self.xl_like:\\n nn.init.xavier_uniform_(self.w_pos.weight)\\n if bias:\\n nn.init.constant_(self.w_pos.bias, 0.0)\",\n \"def init_weights(self):\\n \\n self.w = np.random.randn(self.D) / np.sqrt(self.D)\",\n \"def init_weights(model):\\n ...\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\\n # Tie weights if needed\\n self.tie_weights()\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\",\n \"def reset_parameters(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\",\n \"def reset_parameters(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\",\n \"def init_weights(self, dims):\\n self.W = np.random.normal(size=dims) * 0.0001\",\n \"def reset_parameters_xavier_uniform(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n if self.conv1d is not None:\\n for n, p in self.conv1d.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def InitWeights(self):\\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\\n self.w0 = -1 + 2 * np.random.rand()\",\n \"def _initialize_weights(self):\\n pass\",\n \"def reset_parameters_xavier_uniform(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\",\n \"def reset_parameters_xavier_uniform(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\",\n \"def setWeightInitializer(self,weights):\\n self.init_w = weights\",\n \"def init_weights(self, init_w=3e-3):\\n self.mean_linear.weight.data.uniform_(-init_w, init_w)\\n self.mean_linear.bias.data.uniform_(-init_w, init_w)\\n self.log_std_linear.weight.data.uniform_(-init_w, init_w)\\n self.log_std_linear.bias.data.uniform_(-init_w, init_w)\",\n \"def XavierInit(self):\\n\\n raw_std = (2 / (self.num_input + self.num_output))**0.5\\n if 'relu' == self.act_function:\\n init_std = raw_std * (2**0.5)\\n elif 'sigmoid' == self.act_function:\\n init_std = raw_std\\n else:\\n init_std = raw_std # * 4\\n\\n self.W = np.random.normal(0, init_std, (self.num_input, self.num_output))\\n self.b = np.random.normal(0, init_std, (1, self.num_output))\\n self.v_W = 0\\n self.v_b = 0\",\n \"def weights_initializer(self):\\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]\",\n \"def init_weight(w):\\n shape = w.shape\\n if len(shape) == 4:\\n i, o, u, v = shape\\n k = np.sqrt(6 / (i * u * v + o * u * v))\\n w.data.uniform_(-k, k)\\n elif len(shape) == 2:\\n k = np.sqrt(6 / sum(shape))\\n w.data.uniform_(-k, k)\\n elif len(shape) == 1:\\n w.data.zero_()\",\n \"def _init_weights(self):\\n for layer in self.modules():\\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\\n nn.init.xavier_uniform_(layer.weight)\\n if layer.bias is not None:\\n nn.init.constant_(layer.bias, 0)\\n elif isinstance(layer, nn.BatchNorm1d):\\n nn.init.constant_(layer.weight, 1)\\n nn.init.constant_(layer.bias, 0)\",\n \"def _init_weights(self):\\n for layer in self.modules():\\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\\n nn.init.xavier_uniform_(layer.weight)\\n if layer.bias is not None:\\n nn.init.constant_(layer.bias, 0)\\n elif isinstance(layer, nn.BatchNorm1d):\\n nn.init.constant_(layer.weight, 1)\\n nn.init.constant_(layer.bias, 0)\",\n \"def _init_weights(self):\\n for layer in self.modules():\\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\\n nn.init.xavier_uniform_(layer.weight)\\n if layer.bias is not None:\\n nn.init.constant_(layer.bias, 0)\\n elif isinstance(layer, nn.BatchNorm1d):\\n nn.init.constant_(layer.weight, 1)\\n nn.init.constant_(layer.bias, 0)\",\n \"def init_weight(self):\\n init_bn(self.norm0)\",\n \"def initialize_weights(model: nn.Module, transformer: bool = False) -> None:\\n for param in model.parameters():\\n if param.dim() == 1:\\n if transformer:\\n nn.init.constant_(param, 0.01)\\n else:\\n nn.init.constant_(param, 0)\\n else:\\n nn.init.xavier_normal_(param)\",\n \"def _weight_initializer(self):\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n nn.init.kaiming_normal_(m.weight)\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1.0)\\n nn.init.constant_(m.bias, 0.0)\",\n \"def default_weight_initializer(self):\\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]\",\n \"def weights_init(m):\\n if (\\n isinstance(m, nn.Linear)\\n or isinstance(m, nn.EmbeddingBag)\\n or isinstance(m, nn.Embedding)\\n or isinstance(m, SparseLinear)\\n ):\\n nn.init.xavier_normal_(m.weight)\",\n \"def _weight_initializer(self):\\n for m in self.modules():\\n if isinstance(m, nn.ConvTranspose2d):\\n nn.init.kaiming_normal_(m.weight)\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1.0)\\n nn.init.constant_(m.bias, 0.0)\",\n \"def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):\\n\\n self.params = {}\\n self.params['W1'] = weight_init_std * \\\\\\n np.random.randn(input_size, hidden_size)\\n self.params['b1'] = np.zeros(hidden_size)\\n self.params['W2'] = weight_init_std * \\\\\\n np.random.randn(hidden_size, output_size)\\n self.params['b2'] = np.zeros(output_size)\",\n \"def get_weights(fs, W_init=None, std_scale=0.4):\\n\\n if W_init == None:\\n stddev = std_scale*np.sqrt(2.0 / np.prod(fs[:3]))\\n W_init = torch.normal(torch.zeros(*fs), stddev)\\n\\n W_init = nn.Parameter(W_init) \\n return W_init\",\n \"def init_weights(self, init_w=3e-3):\\n self.l3.weight.data.uniform_(-init_w, init_w)\\n self.l3.bias.data.uniform_(-init_w, init_w)\",\n \"def init_weights(self, init_w=3e-3):\\n self.l3.weight.data.uniform_(-init_w, init_w)\\n self.l3.bias.data.uniform_(-init_w, init_w)\",\n \"def init_weights(m):\\n\\tif type(m) == nn.Linear:\\n\\t\\ttorch.nn.init.xavier_normal(m.weight)\\n\\t\\tm.bias.data.fill_(0.01)\",\n \"def weight_initialization(m: nn.Module) -> None:\\n if type(m) == nn.Linear:\\n # nn.init.xavier_uniform_(m.weight, np.sqrt(2.)) # gain is sqrt(2) because we use ReLU\\n nn.init.kaiming_uniform_(m.weight, a=np.sqrt(5))\\n # nn.init.uniform(m.weight, 0., 0.)\",\n \"def my_assign_weights(context, data):\\n pass\",\n \"def reset_parameters_xavier_uniform(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for n, p in self.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def reset_parameters_xavier_uniform(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for n, p in self.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def init_weights(self):\\r\\n constant_init(self.sampling_offsets, 0.)\\r\\n thetas = torch.arange(\\r\\n self.num_heads,\\r\\n dtype=torch.float32) * (2.0 * math.pi / self.num_heads)\\r\\n grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)\\r\\n grid_init = (grid_init /\\r\\n grid_init.abs().max(-1, keepdim=True)[0]).view(\\r\\n self.num_heads, 1, 1,\\r\\n 2).repeat(1, self.num_levels, self.num_points, 1)\\r\\n for i in range(self.num_points):\\r\\n grid_init[:, :, i, :] *= i + 1\\r\\n\\r\\n self.sampling_offsets.bias.data = grid_init.view(-1)\\r\\n constant_init(self.attention_weights, val=0., bias=0.)\\r\\n xavier_init(self.value_proj, distribution='uniform', bias=0.)\\r\\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\\r\\n self._is_init = True\",\n \"def WeightInitializer():\\n return np.random.uniform(-1, 1)\",\n \"def init_weights(self, load_weights=None):\\n if load_weights:\\n # TODO\\n pass\\n else:\\n # x: lower layer nodes n\\n # y: current layer nodes n\\n x = self.weights_shape[1]\\n y = self.weights_shape[0]\\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member\",\n \"def init_weights(n_input_layer, n_hidden_layer, n_hidden_layer_2, n_output_layer, xavier_init):\\n W1, W2, W3 = None, None, None\\n \\n if xavier_init: # Checks if Xavier initialisation is wanted\\n # Initialises weights depending on number of layers present using:\\n # Normally distributed random number * square_root(1 / number of input neurons to that layer)\\n if n_hidden_layer > 0:\\n W1 = np.random.randn(n_hidden_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\\n\\n if n_hidden_layer_2 > 0:\\n W2 = np.random.randn(n_hidden_layer_2, n_hidden_layer) * np.sqrt(1 / (n_hidden_layer))\\n W3 = np.random.randn(n_output_layer, n_hidden_layer_2) * np.sqrt(1 / (n_hidden_layer_2))\\n\\n else:\\n W2 = np.random.randn(n_output_layer, n_hidden_layer) * np.sqrt(1 / (n_hidden_layer))\\n\\n else:\\n W1 = np.random.randn(n_output_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\\n\\n else:\\n # Weights are randomly picked from a uniform distribution between 0 and 1\\n # They are normalized by making sure the weights sum to 1\\n # Uses different configurations depending on number of layers required\\n if n_hidden_layer > 0:\\n W1 = np.random.uniform(0,1,(n_hidden_layer, n_input_layer))\\n W1 = np.divide(W1,np.matlib.repmat(np.sum(W1,1)[:,None],1,n_input_layer))\\n \\n if n_hidden_layer_2 > 0:\\n W2=np.random.uniform(0,1,(n_hidden_layer_2,n_hidden_layer))\\n W2=np.divide(W2,np.matlib.repmat(np.sum(W2,1)[:,None],1,n_hidden_layer))\\n\\n W3=np.random.uniform(0,1,(n_output_layer,n_hidden_layer_2))\\n W3=np.divide(W3,np.matlib.repmat(np.sum(W3,1)[:,None],1,n_hidden_layer_2))\\n\\n else:\\n W2 = np.random.uniform(0,1,(n_output_layer, n_hidden_layer))\\n W2 = np.divide(W2,np.matlib.repmat(np.sum(W2,1)[:,None],1,n_hidden_layer))\\n\\n else:\\n W1 = np.random.randn(n_output_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\\n\\n return W1, W2, W3\",\n \"def Winit(Weightinit):\\n\\n DicWinit = {'LecunNormal':tf.keras.initializers.lecun_normal(seed=None),\\n 'LecunUniform':tf.keras.initializers.lecun_uniform(seed=None),\\n 'GlorotNormal':tf.keras.initializers.GlorotNormal(seed=None),\\n 'GlorotUniform':tf.keras.initializers.GlorotUniform(seed=None),\\n 'HeNormal':tf.keras.initializers.he_normal(seed=None),\\n 'HeUniform':tf.keras.initializers.he_uniform(seed=None)}\\n return DicWinit[Weightinit]\",\n \"def init_weights(self):\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):\\n xavier_uniform_(m.weight)\\n if m.bias is not None:\\n zeros_(m.bias)\",\n \"def reset_parameters(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for n, p in self.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def reset_parameters(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for n, p in self.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def _WeightInit(self, stddev):\\n return init_ops.truncated_normal_initializer(stddev=stddev)\",\n \"def init_weights(self, sizes, init, X, Y):\\n\\t\\tinit = init.lower()\\n\\n\\t\\tif init == 'none':\\n\\t\\t\\tpass\\n\\t\\telif init == 'zeros':\\n\\t\\t\\tself.wts = arr([np.zeros((sizes[i + 1],sizes[i] + 1)) for i in range(len(sizes) - 1)], dtype=object)\\n\\t\\telif init == 'random':\\n\\t\\t\\tself.wts = arr([.0025 * np.random.randn(sizes[i+1],sizes[i]+1) for i in range(len(sizes) - 1)], dtype=object)\\n\\t\\telse:\\n\\t\\t\\traise ValueError('NNetClassify.init_weights: ' + str(init) + ' is not a valid option for init')\",\n \"def reset_parameters_xavier_uniform(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for conv_layer in [self.pointwise_conv1, self.pointwise_conv2, self.depthwise_conv]:\\n for n, p in conv_layer.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def init_weights(self) -> None:\\n super().init_weights()\\n kaiming_init(self.convs_all_levels, a=1, distribution='uniform')\\n kaiming_init(self.conv_branch, a=1, distribution='uniform')\\n kaiming_init(self.conv_pred, a=1, distribution='uniform')\",\n \"def init_weights(m):\\n if isinstance(m, nn.Linear):\\n nn.init.normal_(m.weight, mean=0.1, std=0.01)\\n nn.init.constant_(m.bias, 0.0)\",\n \"def init_weights(self):\\n if self.init_cfg:\\n super().init_weights()\\n else:\\n # Use smaller std for better stability and performance. We\\n # use 0.1. See more details in \\\"ESRGAN: Enhanced Super-Resolution\\n # Generative Adversarial Networks\\\"\\n for m in [\\n self.conv_first, self.conv_body, self.conv_up1,\\n self.conv_up2, self.conv_hr, self.conv_last\\n ]:\\n default_init_weights(m, 0.1)\",\n \"def _random_weight_initialization(self, mean=0, stddev=1):\\n self.slp_weights = np.random.normal(mean, stddev, size=(self.n_rbfs, self.n_targets))\",\n \"def init_params_weight(row,column):\\n W = np.random.rand(row, column)\\n W = W*2.0-1.0\\n return W.astype(config.floatX) # @UndefinedVariable\",\n \"def initialize_weights(self):\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(\\n self._batch)\",\n \"def init_weights(self):\\n for i in range(5):\\n default_init_weights(getattr(self, f'conv{i+1}'), 0.1)\",\n \"def init_weights(self):\\n if isinstance(self.pretrained, str):\\n logger = get_root_logger()\\n logger.info(f'load model from: {self.pretrained}')\\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\\n elif self.pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n xavier_init(m, distribution='uniform')\\n elif isinstance(m, nn.Linear):\\n normal_init(m, std=0.01)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self):\\r\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\r\\n self.fc.bias.data.fill_(0)\\r\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n if isinstance(self.pretrained, str):\\n logger = get_root_logger()\\n logger.info(f'load model from: {self.pretrained}')\\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\\n elif self.pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n xavier_init(m, distribution='uniform')\\n elif isinstance(m, nn.Linear):\\n normal_init(m, std=0.01)\\n elif isinstance(m, nn.BatchNorm2d):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def ComputeWeights(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\\n ...\",\n \"def init_weights(self):\\n self._q_neuron.h(self._weights) \\n self._q_neuron.x(self._weights)\",\n \"def init_weights(self):\\n for m in self.cls_convs:\\n normal_init(m.conv, std=0.01)\\n for m in self.reg_convs:\\n normal_init(m.conv, std=0.01)\\n normal_init(self.atss_reg, std=0.01)\\n normal_init(self.atss_iou, std=0.01)\\n bias_cls = bias_init_with_prob(0.01)\\n normal_init(self.atss_cls, std=0.01, bias=bias_cls)\",\n \"def __init__(self, alpha, weights):\\n self._weights = weights\\n self._alpha = alpha\",\n \"def reset_parameters(self):\\n if self.W is not None:\\n tanh_gain = weight_init.calculate_gain(\\\"tanh\\\")\\n weight_init.xavier_normal_(self.W, tanh_gain)\\n # self.W.data.uniform_(-0.001, 0.001)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self) -> None:\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def __init__(self, weights):\\n self._weights = weights\",\n \"def initialize_weights(m):\\n if isinstance(m, nn.Linear) or isinstance(m, nn.ConvTranspose2d):\\n init.xavier_uniform(m.weight.data)\",\n \"def __init__(self, size, parameters):\\n\\n self.weights = self.init_weights(size)\\n self.alpha = parameters['alpha']\\n self.epsilon = parameters['epsilon']\\n self.gamma = parameters['gamma']\\n self.value = 0.0 #np.random.random()\",\n \"def _initialize_weights(self, inputs):\\n if self.data_init:\\n self._data_dep_init(inputs)\\n else:\\n self._init_norm()\\n self._initialized = True\",\n \"def _init_weights(module: nn.Module, name: str, head_bias: float = 0., flax=False):\\n if isinstance(module, nn.Linear):\\n if name.startswith('head'):\\n nn.init.zeros_(module.weight)\\n nn.init.constant_(module.bias, head_bias)\\n else:\\n if flax:\\n # Flax defaults\\n lecun_normal_(module.weight)\\n if module.bias is not None:\\n nn.init.zeros_(module.bias)\\n else:\\n # like MLP init in vit (my original init)\\n nn.init.xavier_uniform_(module.weight)\\n if module.bias is not None:\\n if 'mlp' in name:\\n nn.init.normal_(module.bias, std=1e-6)\\n else:\\n nn.init.zeros_(module.bias)\\n elif isinstance(module, nn.Conv2d):\\n lecun_normal_(module.weight)\\n if module.bias is not None:\\n nn.init.zeros_(module.bias)\\n elif isinstance(module, (nn.LayerNorm, nn.BatchNorm2d, nn.GroupNorm)):\\n nn.init.ones_(module.weight)\\n nn.init.zeros_(module.bias)\\n elif hasattr(module, 'init_weights'):\\n # NOTE if a parent module contains init_weights method, it can override the init of the\\n # child modules as this will be called in depth-first order.\\n module.init_weights()\",\n \"def default_weights(n):\\n return np.array([1/n for _ in range(n)])\",\n \"def init_weights(no_input, no_hidden, no_output):\\r\\n weight_lst = []\\r\\n no_of_weights = (no_input * no_hidden) + (no_hidden * no_output)\\r\\n\\r\\n for weight in range(no_of_weights):\\r\\n weight = 0.01 * random.random()\\r\\n weight_lst.append(weight)\\r\\n\\r\\n return weight_lst\",\n \"def xavier_uniform(self, weight, activation):\\n if activation == 'none':\\n nn.init.xavier_uniform(weight, gain=layers.gain(activation))\\n elif activation == 'sigmoid':\\n nn.init.xavier_uniform(weight, gain=layers.gain(activation))\\n elif activation == 'tanh':\\n nn.init.xavier_uniform(weight, gain=layers.gain(activation))\\n elif activation == 'relu':\\n nn.init.xavier_uniform(weight, gain=layers.gain(activation))\",\n \"def init_weights(self):\\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\\n self.fc.out_features)\\n self.fc.weight.data.uniform_(-r, r)\\n self.fc.bias.data.fill_(0)\",\n \"def init_weights(self):\\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\\n self.fc.out_features)\\n self.fc.weight.data.uniform_(-r, r)\\n self.fc.bias.data.fill_(0)\",\n \"def init_weights(self, leveledinit: bool, kernel_size: int, bias: bool) -> None:\\n if leveledinit:\\n nn.init.normal_(self.conv1d.weight, std=1e-3)\\n nn.init.normal_(self.conv1d.bias, std=1e-6)\\n with torch.no_grad():\\n self.conv1d.weight[:, 0, :] += 1.0 / kernel_size\\n else:\\n nn.init.xavier_uniform_(self.conv1d.weight)\\n\\n if self.embed in (\\\"pre\\\", \\\"post\\\"):\\n nn.init.xavier_uniform_(self.embedding.weight)\",\n \"def weights_init(m):\\n if type(m) == torch.nn.Linear:\\n m.weight.data.normal_(0.0, 0.02)\\n m.bias.data.fill_(0)\",\n \"def initialize_weights(self):\\n # compute lmda.\\n self.lmda = float(self.c)/float(self.N)\\n # bias term. This should not get a regularization penalty.\\n self.bias = {}\\n # weight vector\\n self.w = {}\\n # lastW[j] = k, indicates that feature j was last updated at time k.\\n self.lastW = {}\\n for lbl in self.labels:\\n self.bias[lbl] = 0\\n self.w[lbl] = {}\\n self.lastW[lbl] = {}\\n pass\",\n \"def __init__(self, num_parameters=1, init=0.25):\\n super(PReLU, self).__init__()\\n self.num_parameters = num_parameters\\n self.weight = Parameter(Tensor(num_parameters).fill_(init))\",\n \"def initialize_weights(self, weights_initializer, bias_initializer):\\n wshapes = [\\n [self.input_size, self.hidden_size[0]],\\n [self.hidden_size[0], self.hidden_size[1]],\\n [self.hidden_size[1], self.output_size]\\n ]\\n\\n bshapes = [\\n [1, self.hidden_size[0]],\\n [1, self.hidden_size[1]],\\n [1, self.output_size]\\n ]\\n\\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\\n\\n self.trainable_variables = self.weights + self.biases\",\n \"def initialize_weights(training_points):\\n N = len(training_points)\\n ans = {}\\n for p in training_points:\\n ans[p] = make_fraction(1, N)\\n return ans\",\n \"def init_weight(self):\\n init_layer(self.conv1)\\n init_layer(self.conv2)\\n init_bn(self.norm1)\\n init_bn(self.norm2)\",\n \"def init_weights(self, t, prior, scaled_prior = False):\\n from scipy.cluster.vq import kmeans2\\n from scipy.spatial.distance import cdist\\n \\n # check if t has the right shape\\n if not t.ndim == 2:\\n t = t[:, None]\\n \\n if scaled_prior:\\n #self.w1 = np.random.normal(loc=0.0, scale = 1,size=[H, d+1])/np.sqrt(d+1) # 1st layer weights + bias\\n #self.w2 = np.random.normal(loc=0.0, scale = 1,size=[ny, H+1])/np.sqrt(H+1) # 2nd layer weights + bias\\n sigma1 = 1.0/np.sqrt(self.d+1)\\n sigma2 = 1.0/np.sqrt(self.H+1)\\n else:\\n # init weights from gaussian with width given by prior\\n sigma1 = 1.0/np.sqrt(prior)\\n sigma2 = sigma1\\n \\n self.w1 = np.random.normal(loc=0.0, scale = 1,size=[self.H, self.d+1]) * sigma1 # 1st layer weights + bias\\n self.w2 = np.random.normal(loc=0.0, scale = 1,size=[self.ny, self.H+1]) * sigma2 # 2nd layer weights + bias\\n \\n # init biases (taken from netlab, gmminit.m)\\n [centroid, label] = kmeans2(t, self.M)\\n cluster_sizes = np.maximum(np.bincount(label), 1) # avoid empty clusters\\n alpha = cluster_sizes/np.sum(cluster_sizes)\\n if (self.M > 1):\\n # estimate variance from the distance to the nearest centre\\n sigma = cdist(centroid, centroid)\\n sigma = np.min(sigma + np.diag(np.diag(np.ones(sigma.shape))) * 1000, 1)\\n sigma = np.maximum(sigma, np.finfo(float).eps) # avoid underflow\\n else:\\n # only one centre: take average variance\\n sigma = np.mean(np.diag([np.var(t)]))\\n # set biases, taken from netlab, mdninit.m\\n self.w2[0:self.M,0] = alpha\\n self.w2[self.M:2*self.M,0] = np.log(sigma)\\n self.w2[2*self.M:,0] = np.reshape(centroid, [self.M * self.c])\",\n \"def xavier_init(module, gain=1, bias=0, distribution='normal'):\\n # assert distribution in ['uniform', 'normal']\\n if distribution == 'uniform':\\n nn.init.xavier_uniform_(module.weight, gain=gain)\\n else:\\n nn.init.xavier_normal_(module.weight, gain=gain)\\n if hasattr(module, 'bias') and module.bias is not None:\\n nn.init.constant_(module.bias, bias)\",\n \"def initWeights(self):\\n self.weights = []\\n self.bias = []\\n for i, dim in enumerate(self.dimensions[1:]):\\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\\n self.bias.append(np.random.uniform(-1,1,dim))\",\n \"def _initialize_weights(self, m):\\n self.rgen = np.random.RandomState(self.random_state)\\n self.w_ = self.rgen.normal(loc=0.0, scale=0.01, size=m)\\n self.b_ = 0\\n self.w_avg = self.rgen.normal(loc=0.0, scale=0.01, size=m)\\n self.b_avg = 0\\n\\n def net_input(self, X):\\n return np.dot(X, self.w_[1:]) + self.w_[0]\\n\\n def activation(self, X):\\n return X\\n \\n def predict(self, X):\\n return np.where(self.net_input(X) >= 0.0, 1, -1)\\n \\n def get_params(self, deep=True):\\n return {\\\"eta\\\":self.eta, \\\"max_iter\\\":self.max_iter, \\\"C\\\":self.C, \\\"random_state\\\":self.random_state, \\\"batch_size\\\":self.batch_size}\\n \\n def set_params(self, **parameters):\\n for parameter, value in parameters.items():\\n setattr(self, parameters, value)\\n return self\",\n \"def set_weights(self, weights):\\r\\n self.weights = weights\",\n \"def init_weights(self, pretrained=None):\\n if pretrained is not None:\\n self.pretrained = pretrained\\n self.backbone.init_weights(self.pretrained)\\n self.mesh_head.init_weights()\\n if self.with_gan:\\n self.discriminator.init_weights()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75284606","0.7397868","0.7371006","0.7275698","0.72356653","0.7192996","0.7187742","0.71090496","0.7088423","0.7076657","0.7066805","0.70589423","0.70522285","0.70522285","0.6999897","0.69886106","0.6960581","0.69561607","0.69436896","0.6931591","0.6925726","0.6916121","0.6910172","0.68801117","0.68791986","0.68081033","0.68081033","0.68081033","0.68056756","0.6788588","0.6780934","0.67567426","0.6749094","0.67468226","0.67347515","0.6726024","0.6719907","0.6719907","0.6719075","0.6716663","0.6682269","0.66532654","0.66532654","0.6651184","0.6643731","0.6637567","0.66366625","0.66318995","0.66194165","0.6614268","0.6614268","0.6605087","0.6602536","0.6590055","0.6571063","0.6561764","0.6552893","0.6549747","0.65319234","0.652891","0.650085","0.6489609","0.64874274","0.64874274","0.64874274","0.64874274","0.6487107","0.6485418","0.6474626","0.64680016","0.64676356","0.6467193","0.64602953","0.6458401","0.6458401","0.6458401","0.64565176","0.6455572","0.6455519","0.64410007","0.6436869","0.6431529","0.6418534","0.64163864","0.6413167","0.6412508","0.6412508","0.64038384","0.64027953","0.64014703","0.6400184","0.6388945","0.63774765","0.63748276","0.6363368","0.6358107","0.6354525","0.6352981","0.6347089","0.6345133"],"string":"[\n \"0.75284606\",\n \"0.7397868\",\n \"0.7371006\",\n \"0.7275698\",\n \"0.72356653\",\n \"0.7192996\",\n \"0.7187742\",\n \"0.71090496\",\n \"0.7088423\",\n \"0.7076657\",\n \"0.7066805\",\n \"0.70589423\",\n \"0.70522285\",\n \"0.70522285\",\n \"0.6999897\",\n \"0.69886106\",\n \"0.6960581\",\n \"0.69561607\",\n \"0.69436896\",\n \"0.6931591\",\n \"0.6925726\",\n \"0.6916121\",\n \"0.6910172\",\n \"0.68801117\",\n \"0.68791986\",\n \"0.68081033\",\n \"0.68081033\",\n \"0.68081033\",\n \"0.68056756\",\n \"0.6788588\",\n \"0.6780934\",\n \"0.67567426\",\n \"0.6749094\",\n \"0.67468226\",\n \"0.67347515\",\n \"0.6726024\",\n \"0.6719907\",\n \"0.6719907\",\n \"0.6719075\",\n \"0.6716663\",\n \"0.6682269\",\n \"0.66532654\",\n \"0.66532654\",\n \"0.6651184\",\n \"0.6643731\",\n \"0.6637567\",\n \"0.66366625\",\n \"0.66318995\",\n \"0.66194165\",\n \"0.6614268\",\n \"0.6614268\",\n \"0.6605087\",\n \"0.6602536\",\n \"0.6590055\",\n \"0.6571063\",\n \"0.6561764\",\n \"0.6552893\",\n \"0.6549747\",\n \"0.65319234\",\n \"0.652891\",\n \"0.650085\",\n \"0.6489609\",\n \"0.64874274\",\n \"0.64874274\",\n \"0.64874274\",\n \"0.64874274\",\n \"0.6487107\",\n \"0.6485418\",\n \"0.6474626\",\n \"0.64680016\",\n \"0.64676356\",\n \"0.6467193\",\n \"0.64602953\",\n \"0.6458401\",\n \"0.6458401\",\n \"0.6458401\",\n \"0.64565176\",\n \"0.6455572\",\n \"0.6455519\",\n \"0.64410007\",\n \"0.6436869\",\n \"0.6431529\",\n \"0.6418534\",\n \"0.64163864\",\n \"0.6413167\",\n \"0.6412508\",\n \"0.6412508\",\n \"0.64038384\",\n \"0.64027953\",\n \"0.64014703\",\n \"0.6400184\",\n \"0.6388945\",\n \"0.63774765\",\n \"0.63748276\",\n \"0.6363368\",\n \"0.6358107\",\n \"0.6354525\",\n \"0.6352981\",\n \"0.6347089\",\n \"0.6345133\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65751314"},"document_rank":{"kind":"string","value":"54"}}},{"rowIdx":82995,"cells":{"query":{"kind":"string","value":"Generates matrixes and layers to implement internal processing."},"document":{"kind":"string","value":"def build(self):\n \n # Defining the layers\n self.w1 = nn.Linear(self._hidden_size*2, self._expansion_size, bias = False).to(self.device)\n self.tanh = nn.Tanh()\n self.w2 = nn.Linear(self._expansion_size, self._attention_layers, bias = False).to(self.device)\n self.softmax = nn.Softmax(dim = 2)\n self.fc = nn.Linear(self._attention_layers, 1).to(self.device)\n \n if self._activation_fn == 'tanh' or isinstance(self._activation_fn, torch.nn.modules.activation.Tanh):\n self._activation_fn = nn.Tanh()\n elif self._activation_fn == 'sigmoid' or isinstance(self._activation_fn, torch.nn.modules.activation.Sigmoid):\n self._activation_fn = nn.Sigmoid()\n elif self._activation_fn == 'leaky ReLU' or isinstance(self._activation_fn, torch.nn.modules.activation.LeakyReLU):\n self._activation_fn = nn.LeakyReLU()\n else:\n raise NotImplementedError('Non-linear activation function must be \"tanh\", \"sigmoid\" or \"leaky ReLU\"')\n \n # Passing it onto the relevant device\n self._activation_fn = self._activation_fn.to(self.device)"},"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 assembleMatrices(self):\n # All nodes informations\n self.aircraftNodesPoints = []\n self.aircraftMassPoints = []\n self.aircraftMassDistances = []\n self.aircraftSegmentsLengths = []\n self.aircraftNodesNames = []\n self.aircraftInitNodesAreas = []\n self.aircraftNodesA = []\n self.aircraftNodesIy = []\n self.aircraftNodesIz = []\n self.aircraftNodesJ = []\n # More general information\n self.aircraftConnectedNodes = []\n self.aircraftNonRotatingNodes = []\n\n self.computeProportionFuselage()\n self.computeProportionWings()\n\n # adds fulseage infos to matrices if there is one\n if self.nFuselage > 0:\n self.aircraftNodesPoints.append(self.fs_m_points[0])\n # Assumption is made that for a fuselage section, its cog is\n # aligned with the section center.\n self.aircraftMassPoints.append(self.fs_m_points[0])\n self.aircraftMassDistances.append(np.zeros((len(self.fs_m_points[0]),3)))\n self.aircraftSegmentsLengths.append(self.fs_m_distanceBetweenPoints[0])\n self.aircraftNodesNames.append(self.fs_m_pointsName[0])\n self.aircraftInitNodesAreas.append(self.fs_m_pointsInitArea[0])\n self.aircraftNodesA.append(self.fs_m_pointsA[0])\n self.aircraftNodesIy.append(self.fs_m_pointsIy[0])\n self.aircraftNodesIz.append(self.fs_m_pointsIz[0])\n self.aircraftNodesJ.append(self.fs_m_pointsJ[0])\n logger.debug('\\n')\n for i in range(self.nWings):\n self.aircraftNodesPoints.append(self.ws_me_points[i])\n self.aircraftMassPoints.append(self.ws_ma_points[i])\n self.aircraftMassDistances.append(self.ws_ma_distance[i])\n self.aircraftSegmentsLengths.append(self.ws_me_distances[i])\n # logger.debug(i)\n # logger.debug(self.ws_me_distances)\n # logger.debug(self.aircraftSegmentsLengths)\n self.aircraftNodesNames.append(self.ws_me_pointsName[i])\n self.aircraftInitNodesAreas.append(self.ws_me_pointsInitArea[i])\n self.aircraftNodesA.append(self.ws_me_pointsA[i])\n self.aircraftNodesIy.append(self.ws_me_pointsIy[i])\n self.aircraftNodesIz.append(self.ws_me_pointsIz[i])\n self.aircraftNodesJ.append(self.ws_me_pointsJ[i])\n self.computeMass()","def generate_image_matrices():\r\n for i in range(int(number_of_matrices.get())):\r\n clear_space()\r\n populate_image_lists()\r\n randomly_select_images()\r\n get_image_data()\r\n grid_frame = Image.new(\"RGB\", (matrix_x_pix, matrix_y_pix), \"white\")\r\n image_index = 0\r\n for j in range(matrix_x):\r\n for k in range(matrix_y):\r\n img = Image.open(images_total[image_index])\r\n grid_frame.paste(img, (padding + (j * (padding + image_x)),\r\n padding + (k * (padding + image_y))))\r\n image_index += 1\r\n\r\n save_path = (os.path.join(dir_path, \"outputs\\\\\") +\r\n number_of_images_a.get() + \"a\" +\r\n number_of_images_b.get() + \"b_img\" + str(i) + \".png\")\r\n grid_frame.save(save_path, \"PNG\")","def make_all(self):\n # General matrices #\n self.tsv_seq_to_concepts()\n self.tsv_seq_to_names()\n self.list_sequence_concept()\n # Only in the with 'samples' case #\n if self.a.abundances: self.tsv_samples_to_names()\n if self.a.abundances: self.biom_output()\n # Graphical outputs #\n self.per_seq_dot_files()\n if self.a.abundances: self.per_sample_dot_files()","def _derive_transformation_matrices(self):\n\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\n if self._primaries is not None and self._whitepoint is not None:\n npm = normalised_primary_matrix(self._primaries,\n self._whitepoint)\n\n self._derived_RGB_to_XYZ_matrix = npm\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)","def build(self):\n self.build_inputs()\n self.build_word_embeddings()\n self.build_encoder()\n self.build_fc()\n self.build_loss()\n self.build_global_step()","def build_matrix(self):\n self.lb_make = LabelEncoder()\n self.lb_make.fit(self.Y_train)\n tokenizer = Tokenizer(num_words=2000)\n x_array_train = numpy.asarray(self.train['text'])\n x_array_test = numpy.asarray(self.test['text'])\n tokenizer.fit_on_texts(x_array_train)\n x_train_matrix = tokenizer.texts_to_matrix(x_array_train, mode='count')\n x_test_matrix = tokenizer.texts_to_matrix(x_array_test, mode='count')\n y_train_numbers = self.lb_make.transform(self.Y_train)\n y_test_numbers = self.lb_make.transform(self.Y_test)\n y_train_matrix = keras.utils.to_categorical(y_train_numbers, 3)\n y_test_matrix = keras.utils.to_categorical(y_test_numbers, 3)\n self.tokenizer = tokenizer\n return x_train_matrix, x_test_matrix, y_train_matrix, y_test_matrix","def CreateMatrix(self) -> BaseMatrix:","def CreateMatrix(self) -> BaseMatrix:","def build_graph(self):\n self.__create_placeholders()\n self.__create_encoder()\n self.__create_latent()\n self.__create_decoder()\n self.__create_loss()\n self.__create_generate()\n self.__create_reconstruct()\n self.__create_optimizer()\n self.__create_summary()","def build_graph(self):\n\t\tself._create_placeholders()\n\t\tself._create_embedding()\n\t\tself._create_recurrent_layers()\n\t\tself._create_de_embedding()\n\t\tself._create_loss()\n\t\tself._create_optimizer()\n\t\tself._create_summaries()","def create_matrices(self):\n debut = time.process_time()\n\n x = np.arange(0, self.axe_X)\n y = np.arange(0, self.axe_Y)\n xv, yv = np.meshgrid(x, y)\n\n print(\"\\nmatrix creation estimation time: %.1fs\" % (1e-6*self.axe_X*self.axe_Y))\n\n img_matrix_x, img_matrix_y = self.find_position(xv, yv)\n\n fin = time.process_time()\n print(\"matrix created in time: %.1f s\" % (fin-debut))\n return img_matrix_x, img_matrix_y","def _generate_network_initialization(self, graph, memory_manager):\n\n # TODO: To be changed if we want to support multiple outputs\n output_buffer_name = graph.outputs[0].name\n\n ops_to_ignore = ['Reshape', 'Mul']\n\n buffers_allocated = []\n\n buffer_declaration = \"\"\n buffer_declaration += \" pico_cnn::naive::Tensor **kernels;\\n\"\n buffer_declaration += \" pico_cnn::naive::Tensor **biases;\\n\"\n\n constructor_code = \"\"\n #constructor_code += \"Network::Network() {\\n\\n\"\n\n num_layers = 0\n num_kernels = 0\n num_biases = 0\n\n for node in graph.nodes:\n \"\"\"Do not count the reshape layers as the input tensor will only define the dimensions\"\"\"\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n num_layers += 1\n for num, input in enumerate(node.input_tensors):\n if input in buffers_allocated:\n continue\n else:\n tensor = node.input_tensors[input]\n buffers_allocated.append(input)\n if len(tensor.shape) == 1:\n num_biases += 1\n else:\n num_kernels += 1\n\n \"\"\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\"\"\"\n constructor_code += \" kernels = new pico_cnn::naive::Tensor*[{}]();\\n\".format(num_kernels)\n constructor_code += \" biases = new pico_cnn::naive::Tensor*[{}]();\\n\\n\".format(num_biases)\n\n pos = -1\n pos_kernel = -1\n pos_bias = -1\n\n buffers_allocated.clear()\n\n \"\"\"Iterate over all nodes in the graph and generate the corresponding allocation code.\"\"\"\n for node_id, node in enumerate(graph.nodes):\n\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n pos += 1\n\n buffer_declaration += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n constructor_code += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n\n # Allocate memory for kernels and biases\n buffer_declaration += \" // Inputs\\n\"\n constructor_code += \" // Inputs\\n\"\n for num, input in enumerate(node.input_tensors):\n\n if node.op_type in ops_to_ignore:\n continue\n\n if input in buffers_allocated:\n continue\n else:\n buffers_allocated.append(input)\n\n tensor = node.input_tensors[input]\n if len(tensor.shape) == 1:\n pos_bias += 1\n else:\n pos_kernel += 1\n\n buffer = memory_manager.get_buffer(graph, input)\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"KernelAllocation\")\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \" // Outputs\\n\"\n constructor_code += \" // Outputs\\n\"\n for num, output in enumerate(node.outputs):\n\n buffer = memory_manager.get_buffer(graph, output)\n\n if output == output_buffer_name:\n buffer_declaration += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n constructor_code += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n continue\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"OutputAllocation\")\n impl = functionality[0].create(buffer)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \"\\n\\n\"\n constructor_code += \"\\n\\n\"\n\n #constructor_code += \"}\\n\"\n\n self.buffer_declaration = buffer_declaration\n self.constructor_code = constructor_code","def create_training_matrices(experiment, sample_times):\n # Labels:\n location_labels = read_location_labels(experiment)\n locations = get_location_of_persons_at_samples(location_labels, sample_times, experiment)\n\n p1_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P1\")\n p2_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P2\")\n p3_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P3\")\n p4_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P4\")\n\n print(p1_scene_features.loc[0]['predictions'].shape[0])\n print(len(p1_scene_features['predictions'][0]))\n data = {\n \"P1\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P2\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P3\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P4\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0]))\n }\n\n for index, loc_label in enumerate(locations):\n t = loc_label[0]\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P1_eyetracker\")\n p1 = np.mean(p1_scene_features[p1_scene_features['timestamp'].between(t_et - sample_step/2, t_et + sample_step/2)]['predictions'].as_matrix(), axis=0)\n\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P2_eyetracker\")\n p2 = np.mean(\n p2_scene_features[p2_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P3_eyetracker\")\n p3 = np.mean(\n p3_scene_features[p3_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P4_eyetracker\")\n p4 = np.mean(\n p4_scene_features[p4_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n data[\"P1\"][index, 0] = t\n data[\"P1\"][index, 1:-1] = p1\n data[\"P1\"][index, -1] = loc_label[1]\n\n data[\"P2\"][index, 0] = t\n data[\"P2\"][index, 1:-1] = p2\n data[\"P2\"][index, -1] = loc_label[2]\n\n data[\"P3\"][index, 0] = t\n data[\"P3\"][index, 1:-1] = p3\n data[\"P3\"][index, -1] = loc_label[3]\n\n data[\"P4\"][index, 0] = t\n data[\"P4\"][index, 1:-1] = p4\n data[\"P4\"][index, -1] = loc_label[4]\n\n return data","def initParams(self):\n sizes = [self.inputDim]+self.layerSizes+[self.outputDim]\n scales = [np.sqrt(6)/np.sqrt(n+m) for n,m in zip(sizes[:-1],sizes[1:])]\n self.stack = [[np.random.rand(m,n)*2*s-s,np.zeros((m,1))] \\\n for n,m,s in zip(sizes[:-1],sizes[1:],scales)]\n self.hActs_M = [cm.empty((s,self.maxBatch)) for s in sizes]\n\n if self.train:\n # Now assuming that all layers are the same size\n self.grad = [[cm.empty(w.shape),cm.empty(b.shape)] for w,b in self.stack]\n self.deltasC_M = cm.empty((self.outputDim,self.maxBatch))\n self.deltasOut_M = cm.empty((sizes[1],self.maxBatch)) \n self.deltasIn_M = cm.empty((sizes[1],self.maxBatch)) \n self.tmpGrad_M = cm.empty((self.layerSize,self.maxBatch))\n \n # Allocate memory once here and reuse\n # Store probs\n self.probs_M = cm.empty((self.outputDim,self.maxBatch))\n # Store col max\n self.rowVec_M = cm.empty((1,self.maxBatch))\n \n self.stack = [[cm.CUDAMatrix(w),cm.CUDAMatrix(b)]\n for w,b in self.stack]\n\n if self.temporalLayer > 0:\n # dummy bias used for temporal layer\n dummy = cm.empty((1,1))\n dummy.assign(0.0)\n\n scale = np.sqrt(6)/np.sqrt(self.layerSize*2)\n wtf = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\n self.layerSize)-scale)\n wtb = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\n self.layerSize)-scale)\n self.stack.append([wtf,dummy])\n self.stack.append([wtb,dummy])\n\n # forward and backward activations for temporal layer\n self.hActsFor_M = cm.empty((self.layerSize,self.maxBatch))\n self.hActsBack_M = cm.empty((self.layerSize,self.maxBatch))\n\n if self.train:\n dwtf = cm.empty(wtf.shape)\n self.grad.append([dwtf,dummy])\n dwtb = cm.empty(wtb.shape)\n self.grad.append([dwtb,dummy])\n\n self.tmpGradBack_M = cm.empty((self.layerSize,self.maxBatch))\n self.deltasFor_M = cm.empty((self.layerSize,self.maxBatch))\n self.deltasBack_M = cm.empty((self.layerSize,self.maxBatch))","def build(self):\n self.build_inputs()\n self.build_image_embeddings()\n self.build_seq_embeddings()\n self.build_encoder()\n self.build_prediction_model()\n self.setup_encoder_initializer()\n self.setup_global_step()\n self.list_trainable_variables()","def compile(self):\n for layer in self.layers:\n layer._Dense__load()","def build(self):\n self.build_inputs()\n self.image_embeddings = self.build_image_embeddings(self.images)\n self.seq_embeddings = self.build_seq_embeddings(self.input_seqs)\n self.build_model()\n self.setup_inception_initializer()\n self.setup_global_step()","def newMatrix(self):\n self.matrix = makeMatrix()\n for row in range(self.matrix.getHeight()):\n for column in range(self.matrix.getWidth()):\n self.canvasGrid[row][column].draw(self.matrix[row][column])","def generate_mxp_graph(model_name, activations, stats, first_node_name, last_node_name, io_info,\n input_type, ignore_strides=False, inline_depthwise=False, verbose=False):\n network = {}\n network['layers'] = []\n network['test_input'] = None\n network['test_output'] = None\n network['scale'] = 1.0\n\n model = onnx.load(model_name)\n nodes = model.graph.node\n inits = model.graph.initializer\n\n idx = get_node_index(nodes, first_node_name)\n if idx == None:\n if verbose:\n print('{} does not exist\\nopen {} in Netron + check spelling'.format(first_node_name, mname))\n assert(idx != None)\n\n last_idx = get_node_index(nodes, last_node_name)\n if last_idx == None:\n if verbose:\n print('{} does not exist\\nopen {} in Netron + check spelling'.format(last_node_name, mname))\n assert(last_idx != None)\n\n while True:\n node = nodes[idx]\n if verbose:\n print(node.name, node.op_type)\n src_node = get_node_source(nodes, node.input[0])\n if src_node == None:\n input_id = node.input[0]\n else:\n input_id = src_node.output[0]\n output_id = node.output[0]\n\n\n if len(network['layers']) == 0:\n previous = None\n else:\n previous = network['layers'][-1]\n for layer in network['layers']:\n if layer['output_id'] == input_id:\n previous = layer\n\n input_shapes, output_shapes = get_shapes(activations, stats, node)\n assert len(output_shapes) == 1, \"Multi-output nodes not supported\"\n output_shape = output_shapes[0]\n if node.op_type == \"Conv\":\n c, m, n = input_shapes[0]\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\n assert(get_attr(node, 'pads') == None or not any(get_attr(node, 'pads')))\n\n group = get_attr(node, 'group')\n strides = np.asarray(get_attr(node, 'strides')).tolist()\n dilations = np.asarray(get_attr(node, 'dilations')).tolist()\n if not group:\n group = 1\n if not strides:\n strides = [1, 1]\n if not dilations:\n dilations = [1, 1]\n\n use_strided = 0\n assert(strides == [1, 1] or strides == [2, 2] or strides == [4, 4])\n\n if DO_STRIDES and not ignore_strides:\n if (strides[0] > 1 or strides[1] > 1) and group == 1: # TODO handle depthwise as well\n assert(previous['output_size'] == int(np.prod(input_shapes[0])))\n use_strided = 1\n previous['output_strides'] = strides\n if verbose:\n print('adding output strides to previous node')\n\n m = m + (m % strides[0])\n n = n + (n % strides[1])\n if int(np.prod(input_shapes[0])) != int(c*m*n):\n if verbose:\n print('adjusting size for strided maps')\n previous['output_size'] = int(c*4*m//strides[0]*n//strides[1])\n previous['output_shape'] = (c*4,m//strides[0],n//strides[1])\n\n w = get_tensor(inits, node.input[1])\n kernels, channels, _, _ = w.shape\n if len(node.input) == 3:\n b = get_tensor(inits, node.input[2])\n\n conv_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(c*m*n),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels * group,\n 'kernels': kernels,\n 'kernel_shape': kernel_shape,\n 'dilations': dilations,\n 'strides': strides,\n 'group': group,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n 'use_cvi': 0,\n 'use_depthwise': 0,\n 'use_strided': use_strided,\n \"biases\": [],\n \"weights\": [],\n \"sublayers\": [],\n }\n\n w = w.flatten().tolist()\n conv_layer['weights'] = base64.b64encode(struct.pack(\"f\"*len(w), *w)).decode()\n\n if len(node.input) == 3:\n b = b.flatten().tolist()\n else:\n b = [0 for _ in range(kernels)]\n conv_layer['biases'] = base64.b64encode(struct.pack(\"f\"*len(b), *b)).decode()\n\n network['layers'].append(conv_layer)\n\n elif node.op_type == \"Gemm\":\n w = get_tensor(inits, node.input[1])\n output_size, input_size = w.shape\n\n if len(node.input) == 3:\n b = get_tensor(inits, node.input[2])\n\n gemm_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(np.prod(input_shapes[0])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape': output_shape,\n 'gemm_input_size': input_size,\n 'gemm_output_size': output_size,\n 'input_id': input_id,\n 'output_id': output_id,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"biases\": [],\n \"weights\": [],\n \"sublayers\": [],\n }\n\n w = w.flatten().tolist()\n gemm_layer['weights'] = base64.b64encode(struct.pack(\"f\"*len(w), *w)).decode()\n\n if len(node.input) == 3:\n b = b.flatten().tolist()\n else:\n b = [0 for _ in range(output_size)]\n gemm_layer['biases'] = base64.b64encode(struct.pack(\"f\"*len(b), *b)).decode()\n network['layers'].append(gemm_layer)\n\n elif node.op_type in multipath_nodes:\n node_inputs = get_previous_nodes(nodes, node)\n shapes = input_shapes\n\n if node.op_type == \"Sum\":\n assert(all([x == shapes[0] for x in shapes[1:]]))\n elif node.op_type == \"Concat\":\n assert(all([x[1:] == shapes[0][1:] for x in shapes[1:]]))\n\n buf = node_inputs[0].name\n if node.op_type == \"Concat\":\n buf = output_id\n\n buffer_offset = 0\n for n, node_input in enumerate(node_inputs):\n noutput = node_input.output[0]\n for l, layer in enumerate(network['layers']):\n if layer['output_id'] == noutput: # if layer pointing to this node\n network['layers'][l]['output_id'] = buf # rename layer's output\n network['layers'][l]['buffer_offset'] = buffer_offset # and offset appropriately\n if layer['input_id'] == noutput:\n network['layers'][l]['input_id'] = buf #TODO\n\n buffer_offset += int(np.prod(input_shapes[n]))\n\n if node.op_type == \"Sum\":\n channels, m, n = shape3d(output_shape)\n sum_layer = {\n 'op_type': \"Sum\",\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': node_inputs[0].name,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n 'num_inputs': len(node.input),\n \"sublayers\": [],\n }\n network['layers'].append(sum_layer)\n\n elif node.op_type == \"Identity\":\n shapes = input_shapes\n\n channels, m, n = shape3d(output_shape)\n identity_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n }\n network['layers'].append(identity_layer)\n\n elif node.op_type == \"LRN\":\n shapes = input_shapes\n channels, m, n = shape3d(output_shape)\n lrn_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'alpha': get_attr(node, 'alpha'),\n 'beta': get_attr(node, 'beta'),\n 'bias': get_attr(node, 'bias'),\n 'size': get_attr(node, 'size'),\n 'scale': 1.0,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n }\n network['layers'].append(lrn_layer)\n\n elif node.op_type == \"Scale\":\n scale_sublayer = {\n 'op_type': 'Scale',\n 'name': node.name,\n \"use_replay\": 1,\n 'scale': get_attr(node, 'scale'),\n }\n previous['sublayers'].append(scale_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type in [\"GlobalAveragePool\", \"GlobalMaxPool\"]:\n assert(previous['n'] == previous['m'])\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\n strides = np.asarray(get_attr(node, 'strides')).tolist()\n pads = pads6(node)\n pool_sublayer = {\n 'op_type': node.op_type.replace('Global', ''),\n 'name': node.name,\n 'use_replay': 0,\n 'kernel_shape': [previous['m'], previous['n']],\n 'strides': [previous['m'], previous['n']],\n 'pads': pads,\n }\n previous['sublayers'].append(pool_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n previous['output_shape'] = (output_shape)\n\n elif node.op_type in [\"MaxPool\", \"AveragePool\"]:\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\n\n if node.op_type == \"AveragePool\": #TODO quick fix for tf average pool quirk\n if kernel_shape[0] * kernel_shape[1] == previous['m'] * previous['n']:\n kernel_shape = [previous['m'], previous['n']]\n strides = np.asarray(get_attr(node, 'strides')).tolist()\n if strides is None:\n strides = [ 1 for _ in kernel_shape]\n pads = pads6(node)\n pool_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'kernel_shape': kernel_shape,\n 'strides': strides,\n 'pads': pads,\n }\n previous['sublayers'].append(pool_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n previous['output_shape'] = (output_shape)\n elif node.op_type == \"PRelu\":\n slope = get_tensor(inits, node.input[1])\n slope = slope.flatten().tolist()\n prelu_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'slope': slope,\n }\n previous['sublayers'].append(prelu_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"LeakyRelu\":\n alpha = get_attr(node, 'alpha')\n if alpha is None:\n alpha = .01\n leaky_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'alpha': alpha\n }\n previous['sublayers'].append(leaky_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"Relu\":\n relu_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n }\n previous['sublayers'].append(relu_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"Clip\":\n clip_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'min': float(get_tensor(inits,node.input[1])),\n 'max': float(get_tensor(inits,node.input[2])),\n }\n previous['sublayers'].append(clip_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"Pad\":\n pads = pads6(get_tensor(inits,node.input[1]).tolist())\n value = int(get_tensor(inits,node.input[2]))\n if value < -1:\n value = -1\n if value > 1:\n value = 1\n pad_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'value': value,\n 'pads': pads,\n }\n previous['sublayers'].append(pad_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n previous['output_shape'] = (output_shape)\n elif node.op_type in [\"Add\", \"Mul\", \"Sub\", \"Div\"]:\n\n skip = False\n if node.op_type == \"Mul\":\n next_nodes = get_node_inputs(nodes, node.output[0])\n if node.name == nodes[-1].name:\n if verbose:\n print('removing final scale node')\n skip = True\n\n elif previous['op_type'] in [\"LRN\"]:\n if verbose:\n print('skipping mul after lrn')\n array = get_tensor(inits, node.input[1])\n if array is None:\n array = get_tensor(inits, node.input[0])\n previous['scale'] = float(array[0])\n print('skipping mul after lrn', previous['scale'], previous['input_id'], previous['output_id'])\n\n skip = True\n\n elif next_nodes[0].op_type in [\"Softmax\"]:\n if verbose:\n print('skipping mul before softmax')\n skip = True\n\n array = get_tensor(inits, node.input[1])\n if array is None:\n array = get_tensor(inits, node.input[0])\n c = activations[node.input[1]].shape[1]\n else:\n c = input_shapes[0][0]\n\n if node.op_type == \"Add\": # TODO for scalar Add\n dims = len(np.squeeze(array).shape)\n if dims == 0:\n array = np.ones((c, 1)) * array\n\n dims = len(np.squeeze(array).shape)\n if c == 1 and dims == 0:\n dims = 1\n\n array = array.flatten().tolist()\n # force_broadcast_2 = False\n # if force_broadcast_2:\n # # if c != 1 and dims == 0:\n # if c != 1 and dims == 0 and node.op_type != \"Mul\": # TODO forcing to broadcast 2 not broadcast 3\n # dims = 1\n # array = [array[0] for _ in range(c)]\n\n if not skip:\n arithmetic_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'dims': dims,\n 'array': array,\n }\n previous['sublayers'].append(arithmetic_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type in [\"Abs\", \"Max\", \"Mean\", \"Min\", \"Neg\", \"Not\"]:\n unary_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n }\n previous['sublayers'].append(unary_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n\n elif node.op_type == \"Reshape\":\n dims = get_tensor(inits, node.input[1])\n\n if len(dims) == 4 and dims[-1] == 2:\n idx += 6\n node = nodes[idx]\n output_id = node.output[0]\n _, output_shapes = get_shapes(activations, stats, node)\n output_shape = output_shapes[0]\n channels, m, n = shape3d(output_shape)\n reorg_layer = {\n 'op_type': \"Reorg\",\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape': output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n \"stride\": int(dims[-1]),\n }\n network['layers'].append(reorg_layer)\n else:\n previous['output_id'] = output_id\n\n elif node.op_type in [\"Flatten\",'Cast']:\n previous['output_id'] = output_id\n elif node.op_type == \"Resize\":\n scales = get_tensor(inits, node.input[2])\n assert(scales[0] == 1 and scales[1] == 1)\n scale = float(scales[2])\n mode = get_attr(node, 'mode').decode()\n assert(mode == 'nearest' or mode == 'linear')\n shapes = input_shapes[:1]\n channels, m, n = shape3d(output_shape)\n in_size= [d for d in one_elem(input_shapes)[1:]]\n replay = 0 if in_size == [1,1] else 1\n resize_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': replay,\n 'input_size': int(np.prod(one_elem(input_shapes))),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'mode' :mode,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n 'scale': [float(scales[2]),float(scales[3])],\n }\n network['layers'].append(resize_layer)\n elif node.op_type == \"ArgMax\":\n input_shape = one_elem(input_shapes)\n channels, m, n = shape3d(input_shape)\n argmax_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n 'scale': [float(scales[2]),float(scales[3])],\n }\n network['layers'].append(argmax_layer)\n\n elif node.op_type == \"Softmax\":\n prev = get_previous_nodes(nodes, node)[0]\n if prev.op_type == \"Mul\":\n scale = get_tensor(inits, prev.input[1])\n scale = scale.flatten().tolist()\n else:\n scale = [1.0]\n if len(scale) > 1:\n raise NotImplementedError(\"Broadcast scale not implemented for softmax\")\n\n shapes = input_shapes\n channels, m, n = shape3d(output_shape)\n softmax_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n 'scale': scale,\n 'size': len(scale),\n }\n network['layers'].append(softmax_layer)\n\n # softmax_sublayer = {u'op_type': u'Softmax', 'scale': 1.0}\n # previous['sublayers'].append(softmax_sublayer)\n # previous['output_id'] = output_id\n # print('warning SOFTMAX ignored!... fine if last layer and sorting outputs')\n\n elif node.op_type == \"Transpose\":\n shapes = input_shapes\n\n channels, m, n = shape3d(output_shape)\n permutation =[p-1 for p in get_attr(node, 'perm')[1:]]\n transpose_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n 'permutation':permutation,\n \"sublayers\": [],\n }\n network['layers'].append(transpose_layer)\n else:\n raise RuntimeError('Unknown node type:{} '.format(node.op_type))\n\n idx += 1\n if idx > last_idx:\n break\n\n unsigned_network_inputs = input_type == np.uint8\n\n if CVI_1x1:\n network = mxp_gemm_to_conv(network)\n\n network = mxp_set_replay(network, io_info)\n network = mxp_set_cvi(network)\n network = mxp_set_unsigned(network, unsigned_network_inputs)\n\n if inline_depthwise:\n network = mxp_inline_depthwise(network)\n\n network = mxp_describe_layers(network)\n network = mxp_number_buffers(network)\n buffers = mxp_size_buffers(network)\n network = mxp_number_sublayers(network)\n\n network['num_layers'] = len(network['layers'])\n network['buffers'] = buffers\n\n return network","def generate(self):\n self.generate_points()\n self.generate_edges()","def make_matrix():\n\n # this imports category, category, data, text, pptx_data\n\n if use_test_data:\n # make a test matrix using create_test_matrix\n m = matrixfuncs.create_test_matrix()\n\n else:\n # make a matrix by connecting to Slides! and connecting to a data\n # table.\n import transformations.utils.slidesconf as slidesconf\n from Forgetdata.Matrix import ConnectionDefinition\n conn = ConnectionDefinition()\n conn.ConnectionString = mtd_filepath # set at top of file\n conn.Name = \"Test\"\n conn.Provider = \"SPSS MTD File\"\n liveConnection = slidesconf.connect(conn.ConnectionString,\n name=conn.Name,\n provider_name=conn.Provider)\n\n m = liveConnection[table_selected]\n\n x = tr.MatrixManipulator(m)\n matrixfuncs.printMatrix(m)\n\n for c in m[0]:\n c.TopMember.Label = c.TopMember.Label.encode('ascii', 'ignore')\n\n return m, x","def create_matrix(self):\n import random\n random.seed()\n #pecas_disponiveis = [\"escudo\", \"espada\", \"espada_dupla\", \"machadinha\", \"adaga\", \"punhais\"]\n pecas_disponiveis = [\"escudo\", \"punhais\", \"espada_dupla\", \"machadinha\", \"adaga\"]\n x_start, y_start = 10, self.running.top_bar\n x, y = x_start, y_start\n anterior_esq = [None] * self.running.linhas\n anterior_acima = None\n\n for i in range(self.running.colunas):\n coluna = []\n for j in range(self.running.linhas):\n possiveis_escolhas = pecas_disponiveis.copy()\n if possiveis_escolhas.count(anterior_esq[j]) > 0: possiveis_escolhas.remove(anterior_esq[j])\n if possiveis_escolhas.count(anterior_acima) > 0 : possiveis_escolhas.remove(anterior_acima)\n \n e_type = random.choice(possiveis_escolhas)\n tile = Tile(self.game, x, y, e_type)\n coluna.append(tile)\n self.running.game_images.append(tile.game_image)\n y += self.running.y_space\n anterior_esq[j] = e_type\n anterior_acima = e_type\n self.running.tabuleiro.append(coluna)\n x += self.running.x_space\n y = y_start\n return","def create_dev_matrix(self):\n if os.path.exists(self.dev_matrix_h5_path):\n print(\"[LOGGING]: \" + self.dev_matrix_h5_path + \" exists!\")\n return\n\n with h5py.File(self.dev_matrix_h5_path, 'w') as f:\n\n for mode in ['train', 'test']:\n for device in ['a', 'b', 'c']:\n grp = f.create_group(mode + '/' + device)\n grp['data'], grp['label'] = self.extract_npy(mode=mode, devices=device)\n # add parallel data as separate device p\n grp = f.create_group(mode + '/p')\n grp['data'], grp['label'] = self.extrac_para_npy(mode=mode)\n\n # add neg parallel data as device A\n grp = f.create_group(mode + '/A')\n grp['data'], grp['label'] = self.extract_neg_para_npy(mode=mode)\n f.close()","def _generate_adjacency_matrices(self):\n self.adj_matrices = dict()\n mes = []\n args = []\n for metaedge in self.metaedges:\n mes.append(metaedge)\n args.append(self._prepare_parallel_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\n front_num=0)\n for metaedge, matrix in zip(mes, res):\n self.adj_matrices[metaedge] = matrix","def output_rule_feature_matrices():\n with open(config.data_path + config.sentiment_seed, 'rb') as input_file:\n sentiment_dict = pickle.load(input_file)\n seed_sentiments = set(sentiment_dict.keys())\n \n for i in range(len(config.file_names)):\n if i is 5:\n print('processing ', config.file_names[i])\n fname = config.file_names[i]\n feature_x, feature_y, opinion_x, opinion_y = text_to_matrix(\n fname, seed_sentiments)\n feature_x = np.transpose(feature_x)\n opinion_x = np.transpose(opinion_x)\n with open('../results/' + fname + '_rule_feature_matrix.pickle', 'wb') as f:\n pickle.dump(feature_x, f)\n with open('../results/' + fname + '_rule_opinion_matrix.pickle', 'wb') as f:\n pickle.dump(opinion_x, f)\n\n with open('../results/' + fname + '_feature_label.pickle', 'wb') as f:\n pickle.dump(feature_y.ravel(), f)\n with open('../results/' + fname + '_opinion_label.pickle', 'wb') as f:\n pickle.dump(opinion_y.ravel(), f)","def get_linear_discrete_matrices(self):\n\n vf_op, vb_op = get_operating_point_inputs(self.operating_point[1], self.model_type)\n if self.model_type == ModelType.EASY:\n At, Bt, Vf_op, Vd_op = getLinearizedMatrices(self.model_type, self.operating_point[0:6], vf_op, vb_op)\n elif self.model_type == ModelType.GYROMOMENT:\n At, Bt = get_gyro_matrices(self.operating_point, self.operating_point[6] / mc.K_f, vf_op, vb_op)\n if self.model_type == ModelType.EASY:\n Ct = np.array([[1, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0]])\n Dt = np.array([[0, 0],\n [0, 0],\n [0, 0]])\n elif self.model_type == ModelType.GYROMOMENT:\n if self.nOutputs == 3:\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0]])\n Dt = np.array([[0, 0],\n [0, 0],\n [0, 0],\n [0, 0],\n [0, 0]])\n elif self.nOutputs == 5:\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 1, 0],\n [0, 0, 0, 0, 0, 0, 0, 1]])\n Dt = np.array([[0, 0],\n [0, 0],\n [0, 0],\n [0, 0],\n [0, 0]])\n\n Ak, Bk, Ck, Dk = discretize_linear_state_space(At, Bt, Ct, Dt, self.timeStep)\n return Ak, Bk, Ck, Dk","def make_input_materials(self) :\n # 1 5 1 MATERIAL 1 (arbitrary line, i think) \n # 1.4493e+00 9.9000e-03 7.9000e-03 1. 0. 0. 7.9000e-03 1.\n # 3.8070e-01 1.0420e-01 1.6920e-01 0 1.5100e-02 0. 1.6920e-01 1.\n self.input_materials = \"\"\n number_mats = len(self.core.pattern)+1\n a = self.core.assemblies\n for i in range(0, number_mats-1) :\n # Row 1: description.\n self.input_materials += \" \" + str(i+1) + \" 5 1 MATERIAL \" + \\\n str(i+1) + \" (\" + \\\n a[i].model + \", \" + \\\n str(a[i].enrichment) + \" w/o, \" + \\\n str(a[i].burnup) + \" MWd/kg)\\n\" \n # Rows 2 and 3.\n D1,D2,A1,A2,F1,F2,S12 = a[i].get_constants()\n d = np.array([[D1,A1,F1,1.0,0.0,0.0,F1,1.0],[D2,A2,F2,0.0,S12,0.0,F2,1.0]])\n for j in range(0, 2) :\n for k in range(0, 8) :\n self.input_materials +='%12.4e' %(d[j,k])\n self.input_materials += '\\n'\n \n a = self.core.reflector\n # Row 1: description.\n self.input_materials += \" \" + str(number_mats) + \" 5 1 MATERIAL \" + \\\n str(number_mats) + \" (REFLECTOR) \\n\" \n # Rows 2 and 3.\n D1,D2,A1,A2,F1,F2,S12 = a.get_constants()\n d = np.array([[D1,A1,F1,1.0,0.0,0.0,F1,1.0],[D2,A2,F2,0.0,S12,0.0,F2,1.0]])\n for i in range(0, 2) :\n for j in range(0, 8) :\n self.input_materials +='%12.4e' %(d[i,j])\n self.input_materials += '\\n'\n self.input_materials += \"WHITE\\n\" + \"BLACK\\n\" + \"END\\n\"","def create_weight_matrices(self):\n rad = 1 / np.sqrt(self.no_of_in_nodes)\n X = truncated_normal(mean=0, \n sd=1, \n low=-rad, \n upp=rad)\n self.wih = X.rvs((self.no_of_hidden_nodes, \n self.no_of_in_nodes))\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\n self.who = X.rvs((self.no_of_out_nodes, \n self.no_of_hidden_nodes))","def _calc_matrix(self):\n\t\tz = self.zoom\n\t\talloc = self.allocation\n\t\tif self.image:\n\t\t\tiw, ih = self.image.get_width(), self.image.get_height()\n\t\telse:\n\t\t\tiw, ih = 0, 0\n#\t\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\n\t\t\n\t\ti2w = cairo.Matrix(\n\t\t\tz,0,\n\t\t\t0,z,\n\t\t\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \n\t\t\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\n\t\t\t)\n\t\t\n\t\tself._i2w_matrix = i2w\n\t\t\n\t\tw2i = cairo.Matrix(*i2w) #copy\n\t\tw2i.invert()\n\t\tself._w2i_matrix = w2i","def _build_model(self):\n\n with tf.variable_scope(\"Matchnet\", reuse=tf.AUTO_REUSE):\n # For determining the runtime shape\n x_shp = tf.shape(self.x_in)\n\n # -------------------- Network archintecture --------------------\n # Build graph\n print(\"Building Graph\")\n self.logits = build_graph(self.x_in, self.is_training, self.config)\n # ---------------------------------------------------------------\n\n # Turn into weights for each sample\n weights = tf.nn.relu(tf.tanh(self.logits))\n\n # Make input data (num_img_pair x num_corr x 4)\n xx = tf.transpose(tf.reshape(\n self.x_in, (x_shp[0], x_shp[2], 4)), (0, 2, 1))\n\n # Create the matrix to be used for the eight-point algorithm\n X = tf.transpose(tf.stack([\n xx[:, 2] * xx[:, 0], xx[:, 2] * xx[:, 1], xx[:, 2],\n xx[:, 3] * xx[:, 0], xx[:, 3] * xx[:, 1], xx[:, 3],\n xx[:, 0], xx[:, 1], tf.ones_like(xx[:, 0])\n ], axis=1), (0, 2, 1))\n print(\"X shape = {}\".format(X.shape))\n wX = tf.reshape(weights, (x_shp[0], x_shp[2], 1)) * X\n print(\"wX shape = {}\".format(wX.shape))\n XwX = tf.matmul(tf.transpose(X, (0, 2, 1)), wX)\n print(\"XwX shape = {}\".format(XwX.shape))\n\n # Recover essential matrix from self-adjoing eigen\n e, v = tf.self_adjoint_eig(XwX)\n self.e_hat = tf.reshape(v[:, :, 0], (x_shp[0], 9))\n # Make unit norm just in case\n self.e_hat /= tf.norm(self.e_hat, axis=1, keep_dims=True)","def build_augmented_matrix(self):\r\n for row in range(self.SIZE):\r\n self.matrix[row].append(self.result[row])","def generate(self):\n self.training_data.gen_x(self.x_func)\n self.training_data.gen_a(self.a_func)\n self.training_data.gen_y(self.y_func)\n \n self.testing_data.gen_x(self.x_func)\n self.testing_data.gen_ys(self.y_func)\n self.testing_data.gen_azero(self.ytotal_func)","def build_modules(self):\n self.backbone = Backbone(\n self.configs['backbone'],\n freeze_backbone=self.configs['freeze_backbone'],\n freeze_batchnorm=True\n )\n\n backbone_channel_sizes = get_backbone_channel_sizes(self.backbone)\n\n self.fpn = FeaturePyramidNetwork(\n backbone_channel_sizes=backbone_channel_sizes,\n min_feature_level=self.configs['min_feature_level'],\n max_feature_level=self.configs['max_feature_level'],\n feature_size=self.configs['pyramid_feature_size']\n )\n\n self.shared_conv_model = SharedConvModel(\n input_feature_size=self.configs['pyramid_feature_size'],\n feature_size=self.configs['shared_conv_feature_size'],\n num_layers=self.configs['shared_conv_num_layers']\n )\n\n if self.configs['shared_conv_num_layers'] > 0:\n shared_conv_output_size = self.configs['shared_conv_feature_size']\n else:\n shared_conv_output_size = self.configs['pyramid_feature_size']\n\n self.ofn = ObjectFinderNetwork(\n input_feature_size=shared_conv_output_size,\n feature_size=self.configs['finder_feature_size'],\n num_layers=self.configs['finder_num_layers']\n )\n\n self.ofn_loss_fn\n\n # self.classification_model = ClassificationModel()\n #\n # self.regression_model = RegressionModel()","def build(node):\n yield Matrix(node[Matrix.TAG])","def createMatrices(file, word2Idx, maxSentenceLen, extendMapping, labelsMapping, aspectMapping, typeMapping, tenseMapping, eventClassMapping, distanceMapping, sentenceLengthMapping):\n labels = []\n eventMatrix = []\n timeMatrix = []\n\n sentenceLengths = []\n sentenceMatrix = []\n positionMatrix_e = []\n positionMatrix_t = []\n\n aspectMatrix = []\n typeMatrix = []\n tenseMatrix = []\n eventClassMatrix = []\n featuresList = []\n \n \n minDistance = 0\n for distanceKey in distanceMapping.iterkeys():\n if isinstance(distanceKey, (int, long)):\n minDistance = min(minDistance, int(distanceKey))\n \n for line in open(file):\n features = eval(line.strip())\n featuresList.append(features)\n label = features['label']\n event = features[\"Token[0]\"]\n eventPosition = int(features[\"eventPosition\"])\n tokens = features[\"textInBetween\"] if \"textInBetween\" in features else features[\"sentence\"]\n \n aspect = features[\"aspect\"]\n tense = features[\"tense\"]\n eventClass = features[\"eventClass\"]\n \n labels.append(labelsMapping[label.lower()] if label.lower() in labelsMapping else -1)\n eventMatrix.append(getWordIdx(event, word2Idx))\n \n aspectMatrix.append(getMappingIdx(aspect, aspectMapping, extendMapping))\n tenseMatrix.append(getMappingIdx(tense, tenseMapping, extendMapping))\n eventClassMatrix.append(getMappingIdx(eventClass, eventClassMapping, extendMapping))\n \n if 'TimeTokenFirst' in features:\n time = features['TimeTokenFirst']\n timeMatrix.append(getWordIdx(time, word2Idx))\n \n if 'type' in features:\n type = features[\"type\"]\n typeMatrix.append(getMappingIdx(type, typeMapping, extendMapping))\n \n timePosition = int(features[\"timeFirstPosition\"]) if 'timeFirstPosition' in features else 0\n \n\n if len(tokens) in sentenceLengthMapping:\n sentenceLengths.append(sentenceLengthMapping[len(tokens)])\n else:\n sentenceLengths.append(sentenceLengthMapping['GreaterMax'])\n\n \n tokenIds = np.zeros(maxSentenceLen)\n positionValues_e = np.zeros(maxSentenceLen)\n positionValues_t = np.zeros(maxSentenceLen)\n for idx in xrange(0, min(maxSentenceLen, len(tokens))):\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\n \n distance_e = idx - eventPosition\n distance_t = idx - timePosition\n\n if distance_e in distanceMapping:\n positionValues_e[idx] = distanceMapping[distance_e]\n elif distance_e <= minDistance:\n positionValues_e[idx] = distanceMapping['LowerMin']\n else:\n positionValues_e[idx] = distanceMapping['GreaterMax']\n \n if distance_t in distanceMapping:\n positionValues_t[idx] = distanceMapping[distance_t]\n elif distance_t <= minDistance:\n positionValues_t[idx] = distanceMapping['LowerMin']\n else:\n positionValues_t[idx] = distanceMapping['GreaterMax']\n\n sentenceMatrix.append(tokenIds)\n positionMatrix_e.append(positionValues_e)\n positionMatrix_t.append(positionValues_t)\n\n \n labels = np.array(labels, dtype='int32')\n eventMatrix = np.expand_dims(np.array(eventMatrix, dtype='int32'), axis=1)\n timeMatrix = np.expand_dims(np.array(timeMatrix, dtype='int32'), axis=1)\n aspectMatrix = np.expand_dims(np.array(aspectMatrix, dtype='int32'), axis=1)\n typeMatrix = np.expand_dims(np.array(typeMatrix, dtype='int32'), axis=1)\n tenseMatrix = np.expand_dims(np.array(tenseMatrix, dtype='int32'), axis=1)\n eventClassMatrix = np.expand_dims(np.array(eventClassMatrix, dtype='int32'), axis=1)\n sentenceLengths = np.expand_dims(np.array(sentenceLengths, dtype='int32'), axis=1)\n \n \n sentenceMatrix = np.array(sentenceMatrix, dtype='int32')\n positionMatrix_e = np.array(positionMatrix_e, dtype='int32')\n positionMatrix_t = np.array(positionMatrix_t, dtype='int32')\n \n\n\n return {'labels': labels,\n 'event':eventMatrix, \n 'time':timeMatrix, \n 'sentence':sentenceMatrix, \n 'positions_e':positionMatrix_e, \n 'positions_t':positionMatrix_t, \n 'aspect':aspectMatrix, \n 'tense':tenseMatrix, \n 'eventClass':eventClassMatrix, \n 'type': typeMatrix,\n 'sentence_len': sentenceLengths,\n 'features': featuresList}","def run(self):\n # load_data\n layers = self.load_all_data() # list of tuples (file_name, feature_matrix)\n\n # check variable types\n if len(self.method) == 1:\n self.method = [self.method[0]] * len(layers)\n elif len(layers) != len(self.method):\n raise ValueError(\"Number of matrices extracted from input files and number of similarity methods \" +\n \"does not correspond\")\n\n # check missing value parameter\n if len(self.missing) == 1:\n self.logger.info(\"#Setting all 'missing' parameters to {}\".format(self.missing[0]))\n self.missing = [self.missing[0]] * len(layers)\n elif len(layers) != len(self.missing):\n raise ValueError(\"Number of matrices extracted from input files and number of given missing parameters \" +\n \"does not correspond\")\n\n # extract sample names\n all_samples = set()\n for layer_data in layers:\n all_samples = all_samples.union({name for name in layer_data[1].columns})\n self.logger.info(\"#Total number of unique samples: {}\".format(len(all_samples)))\n\n out_arrays = {}\n adj_matrices = []\n\n # create adjacency matrices\n for i in range(len(layers)):\n self.logger.info(\"#Layer: {}\".format(i))\n layer_data = layers[i][1]\n\n # add missing samples layer\n samples = {name for name in layer_data.columns}\n for name in all_samples - samples:\n layer_data[name] = np.nan\n\n # sort data frame by sample names\n layer_data.sort_index(axis=1, inplace=True)\n\n # extract feature matrices\n f = layer_data.values.T\n self.logger.info(\"Feature matrix: ({} samples x {} features)\".format(f.shape[0], f.shape[1]))\n\n # check if feature matrix values are correct\n ncat = check_categories(f)\n if ncat != [0, 1]:\n standardized = is_standardized(f, axis=0, atol=self.atol)\n if not standardized[0]:\n raise ValueError(\"Incorrect values in feature matrix. Mean of features in \" +\n \"({},{}) \".format(round(standardized[1][0], 3), round(standardized[1][1], 3)) +\n \"range. Standard deviation of features in \" +\n \"({}, {}) \".format(round(standardized[2][0], 3), round(standardized[2][1], 3)) +\n \"range. Please, supply either binary dataset \" +\n \"(0 or 1 feature values) or continuous values standardized feature-wise. \" +\n \"Alternatively for almost standardized continuous data, \" +\n \"increase '-atol' parameter value (currently {}).\".format(self.atol))\n else:\n self.logger.debug(\"Data is correctly standardized\")\n else:\n self.logger.debug(\"Found two unique categories in data: [0, 1]\")\n if self.method[i] != 'cosine':\n self.logger.info(\"Using '{}' similarity for [0, 1] data. \".format(self.method[i]) +\n \"Suggested better measure: cosine similarity.\")\n\n # create adjacency matrix\n a = feature_to_adjacency(f, missing=self.missing[i], method=self.method[i], n=self.k, alpha=self.alpha)\n self.logger.info('Adjacency matrix {} created [similarity method: {}]'.format(a.shape, self.method[i]))\n\n # plot adjacency matrix\n plot_path = self.plot_base + \"_\" + str(i) + \".png\" if self.plot else self.plot_base\n plot_heatmap_seaborn(a, title=\"Layer {} (source:{})\".format(i, layers[i][0]), file_path=plot_path)\n if self.plot:\n self.logger.info(\"Adjacency matrix plot saved to {}\".format(plot_path))\n\n # add matrices to output arrays\n out_arrays[str(i)] = a\n adj_matrices.append(a)\n out_arrays[\"f\" + str(i)] = f\n\n # check if there are samples not accessible in any layer\n missing_samples = []\n for a in adj_matrices:\n missing_samples += [i for i in range(a.shape[1]) if np.all(np.isnan(a[:, i]))]\n\n samples_to_drop = [sample for sample, val in Counter(missing_samples).items() if val == len(adj_matrices)]\n if samples_to_drop:\n # drop inaccessible samples\n self.logger.info(\"Found samples inaccessible in every layer of graph. \" +\n \"Try changing '-missing' parameter or inspect your data \")\n sample_names = np.array(sorted(list(all_samples)))[np.array(samples_to_drop)]\n self.logger.info(\"Dropped samples: {}\".format(list(sample_names)))\n updated_out_arrays = {}\n selector = np.array([x for x in range(len(all_samples)) if x not in samples_to_drop])\n for i in range(len(out_arrays.keys())):\n if str(i) not in out_arrays.keys():\n break\n updated_out_arrays[str(i)] = out_arrays[str(i)][selector[:, None], selector]\n updated_out_arrays[\"f\" + str(i)] = out_arrays[\"f\" + str(i)][selector, :]\n\n # create output file\n updated_out_arrays[\"samples\"] = np.array(sorted(list(all_samples)))[selector]\n save_arrays_to_npz(data=updated_out_arrays, file_path=self.outfile)\n\n else:\n # create output file\n out_arrays[\"samples\"] = np.array(sorted(list(all_samples)))\n save_arrays_to_npz(data=out_arrays, file_path=self.outfile)\n\n self.logger.info(\"#Output file {} created\".format(self.outfile))","def build_generator2D_(self, model_shape, filters=32, k_size=4, z_size=500, summary=False, model_file=None, name='gan_g_'):\n if (model_file):\n \"\"\"\n Load pretreined model\n \"\"\"\n model = self.utils.build_pretrained_model(model_file)\n if (summary):\n model.summary()\n return model\n else:\n\n n_rows = model_shape[0]\n n_cols = model_shape[1]\n c_dims = model_shape[2]\n input_shape = (z_size,)\n if n_rows % 8 !=0:\n height = n_rows//8 + 1\n else:\n height = n_rows//8\n if n_cols % 8 !=0:\n width = n_cols//8 +1\n else:\n width = n_cols//8\n \n num_init_neurons = 8*filters \n reshape_size= (height, width, num_init_neurons)\n \n # 8*height, 4*height, 2*height, height = n_rows, n_rows//2, n_rows//4, n_rows//8\n rows_matching = np.equal([2*height, 4*height, 8*height], [n_rows//4, n_rows//2, n_rows])\n index_rows = np.where(np.logical_not(rows_matching))[0]\n if len(index_rows) > 0:\n index_rows = index_rows[0]\n # print(index_rows)\n # 8*width, 4*width, 2*width, width = n_cols//1, n_cols//2, n_cols//4, n_cols//8\n cols_matching = np.equal([2*width, 4*width, 8*width], [n_cols//4, n_cols//2, n_cols])\n index_cols = np.where(np.logical_not(cols_matching))[0]\n if len (index_cols) > 0:\n index_cols = index_cols[0]\n # print(index_cols)\n\n input_layer = Input(shape=input_shape, name=name+'input')\n g = Dense(width * height * num_init_neurons, kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(input_layer)\n g = Reshape(reshape_size, name=name+'reshape')(g)\n g = BatchNormalization(momentum=0.8, name=name+'bn_dense')(g, training=True)\n g = Activation(activation='relu', name=name+'relu')(g)\n\n g = self.Conv2DTranspose_Block(g, 4*filters, name=name+'1')\n if index_rows==0 or index_cols==0:\n g = BilinearUpsampling(output_size=(n_rows//4, n_cols//4), name=name+'bilinear')(g)\n g = self.Conv2DTranspose_Block(g, 2*filters, k_size=k_size, name=name+'2')\n if index_rows==1 or index_cols==1:\n g = BilinearUpsampling(output_size=(n_rows//2, n_cols//2), name=name+'bilinear')(g)\n g = self.Conv2DTranspose_Block(g, 1*filters, k_size=k_size, name=name+'3')\n if index_rows==2 or index_cols==2:\n g = BilinearUpsampling(output_size=(n_rows, n_cols), name=name+'bilinear')(g) \n g = self.Conv2DTranspose_Block(g, c_dims, strides=1, activation='tanh', k_size=k_size, name=name+'4', bn=False)\n\n model = Model(inputs=[input_layer], outputs=[g], name='Generator')\n if (summary):\n model.summary()\n return model","def __init__(\n self,\n numpy_rng,\n train_set_x,\n train_set_y,\n hidden_layers_sizes,\n n_ins=784,\n n_outs=10\n ):\n\n self.sigmoid_layers = []\n self.AE_layers = []\n self.params = []\n self.n_layers = len(hidden_layers_sizes)\n self.train_set_x = train_set_x\n self.train_set_y = train_set_y\n\n assert self.n_layers > 0\n\n self.x = T.matrix('x') # the data is presented as rasterized images\n self.y = T.ivector('y') # the labels are presented as 1D vector of\n\n for i in xrange(self.n_layers): # used to be n layers\n\n # construct the sigmoid layer = encoder stack\n if i == 0:\n layer_input = self.x\n else:\n layer_input = self.sigmoid_layers[-1].output\n\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\n input=layer_input,\n n_in=(n_ins if i == 0 else\n hidden_layers_sizes[i-1]),\n n_out=hidden_layers_sizes[i],\n activation=T.nnet.sigmoid)\n\n # add the layer to our list of layers\n self.sigmoid_layers.append(sigmoid_layer)\n self.params.extend(sigmoid_layer.params)\n\n # init the DA_layer, takes weights from sigmoid layer\n AE_layer = AutoEncoder(\n numpy_rng=numpy_rng,\n input=layer_input,\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\n n_hidden=hidden_layers_sizes[i],\n W=sigmoid_layer.W,\n bhid=sigmoid_layer.b)\n\n self.AE_layers.append(AE_layer)\n\n # on top of the layers\n # log layer for fine-tuning\n self.logLayer = LogisticRegression(\n input=self.sigmoid_layers[-1].output,\n n_in=hidden_layers_sizes[-1],\n n_out=n_outs\n )\n self.params.extend(self.logLayer.params)\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\n self.errors = self.logLayer.errors(self.y)","def generate(self):\n t_0 = time()\n\n if self.random_towers:\n self.towers = np.random.rand(self.number_towers, 2)\n else:\n step = np.ceil(np.sqrt(self.number_towers)).astype('int')\n\n if step ** 2 != self.number_towers:\n self.number_towers = step ** 2\n print(f'WARNING: number of towers changed to {self.number_towers}')\n\n X, Y = np.mgrid[0:1:step * 1j, 0:1:step * 1j]\n positions = np.vstack([X.ravel(), Y.ravel()])\n self.towers = positions.swapaxes(1, 0)\n\n self.towers_manager = TowersManager(self.towers, self.vel_friction)\n\n self.distances = self.towers_manager.generate_distances()\n self.print(f'Took {time() - t_0} to create distrances matrix')\n\n t = time()\n self.probabilities = self.generate_probabilities()\n self.print(f'Took {time() - t} to create probabilities matrix')\n\n t = time()\n self.traces = self.generate_weighted_users_traces()\n self.print(f'Took {time() - t} to create user traces')\n\n t = time()\n self.aggregated_data = self.generate_aggregate_data()\n self.print(f'Took {time() - t} to build aggregated data')\n\n self.print(f'Took {time() - t_0} to generate all')","def convert(self):\n self.tilewidth = int(self.tilewidth)\n self.tileheight = int(self.tileheight)\n self.width = int(self.width)\n self.height = int(self.height)\n self.pixel_width = self.width * self.tilewidth\n self.pixel_height = self.height * self.tileheight\n for layer in self.layers:\n self.named_layers[layer.name] = layer\n layer.opacity = float(layer.opacity)\n layer.x = int(layer.x)\n layer.y = int(layer.y)\n layer.width = int(layer.width)\n layer.height = int(layer.height)\n layer.pixel_width = layer.width * self.tilewidth\n layer.pixel_height = layer.height * self.tileheight\n layer.visible = bool(int(layer.visible))\n for tile_set in self.tile_sets:\n self.named_tile_sets[tile_set.name] = tile_set\n tile_set.spacing = int(tile_set.spacing)\n tile_set.margin = int(tile_set.margin)\n for img in tile_set.images:\n if img.trans:\n img.trans = (int(img.trans[:2], 16), int(img.trans[2:4], 16), int(img.trans[4:], 16))\n for obj_group in self.object_groups:\n obj_group.x = int(obj_group.x)\n obj_group.y = int(obj_group.y)\n obj_group.width = int(obj_group.width)\n obj_group.height = int(obj_group.height)\n for map_obj in obj_group.objects:\n map_obj.x = int(map_obj.x)\n map_obj.y = int(map_obj.y)\n map_obj.width = int(map_obj.width)\n map_obj.height = int(map_obj.height)","def convert(self):\n self.tilewidth = int(self.tilewidth)\n self.tileheight = int(self.tileheight)\n self.width = int(self.width)\n self.height = int(self.height)\n self.pixel_width = self.width * self.tilewidth\n self.pixel_height = self.height * self.tileheight\n for layer in self.layers:\n self.named_layers[layer.name] = layer\n layer.opacity = float(layer.opacity)\n layer.x = int(layer.x)\n layer.y = int(layer.y)\n layer.width = int(layer.width)\n layer.height = int(layer.height)\n layer.pixel_width = layer.width * self.tilewidth\n layer.pixel_height = layer.height * self.tileheight\n layer.visible = bool(int(layer.visible))\n for tile_set in self.tile_sets:\n self.named_tile_sets[tile_set.name] = tile_set\n tile_set.spacing = int(tile_set.spacing)\n tile_set.margin = int(tile_set.margin)\n for img in tile_set.images:\n if img.trans:\n img.trans = (int(img.trans[:2], 16), int(img.trans[2:4], 16), int(img.trans[4:], 16))\n for obj_group in self.object_groups:\n obj_group.x = int(obj_group.x)\n obj_group.y = int(obj_group.y)\n obj_group.width = int(obj_group.width)\n obj_group.height = int(obj_group.height)\n for map_obj in obj_group.objects:\n map_obj.x = int(map_obj.x)\n map_obj.y = int(map_obj.y)\n map_obj.width = int(map_obj.width)\n map_obj.height = int(map_obj.height)","def create_matrix(self):\n\n self.matrix = np.zeros((len(self.users), len(self.items)))\n\n for user in self.train_set['users']:\n for item in self.train_set['feedback'][user]:\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\n self.train_set['feedback'][user][item]","def build_generator2D(self, model_shape, filters=32, k_size=4, z_size=500, summary=False, model_file=None, name='gan_g_'):\n if (model_file):\n \"\"\"\n Load pretreined model\n \"\"\"\n model = self.utils.build_pretrained_model(model_file)\n if (summary):\n model.summary()\n return model\n else:\n\n n_rows = model_shape[0]\n n_cols = model_shape[1]\n input_shape = (z_size,)\n if n_rows % 8 !=0:\n height = n_rows//8 + 1\n else:\n height = n_rows//8\n if n_cols % 8 !=0:\n width = n_cols//8 +1\n else:\n width = n_cols//8\n \n num_init_neurons = 8*filters \n reshape_size= (height, width, num_init_neurons)\n \n # 8*height, 4*height, 2*height, height = n_rows, n_rows//2, n_rows//4, n_rows//8\n rows_matching = np.equal([2*height, 4*height, 8*height], [n_rows//4, n_rows//2, n_rows])\n index_rows = np.where(np.logical_not(rows_matching))[0]\n if len(index_rows) > 0:\n index_rows = index_rows[0]\n # print(index_rows)\n # 8*width, 4*width, 2*width, width = n_cols//1, n_cols//2, n_cols//4, n_cols//8\n cols_matching = np.equal([2*width, 4*width, 8*width], [n_cols//4, n_cols//2, n_cols])\n index_cols = np.where(np.logical_not(cols_matching))[0]\n if len (index_cols) > 0:\n index_cols = index_cols[0]\n # print(index_cols)\n\n input_layer = Input(shape=input_shape, name=name+'input')\n g = Dense(width * height * num_init_neurons, kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(input_layer)\n g = Reshape(reshape_size, name=name+'reshape')(g)\n g = BatchNormalization(momentum=0.8, name=name+'bn_dense')(g, training=True)\n g = Activation(activation='relu', name=name+'relu')(g)\n\n g = self.Conv2DTranspose_Block(g, 4*filters, name=name+'1')\n if index_rows==0 or index_cols==0:\n g = BilinearUpsampling(output_size=(n_rows//4, n_cols//4), name=name+'bilinear')(g)\n g = self.Conv2DTranspose_Block(g, 2*filters, k_size=k_size, name=name+'2')\n if index_rows==1 or index_cols==1:\n g = BilinearUpsampling(output_size=(n_rows//2, n_cols//2), name=name+'bilinear')(g)\n g = self.Conv2DTranspose_Block(g, 1*filters, k_size=k_size, name=name+'3')\n if index_rows==2 or index_cols==2:\n g = BilinearUpsampling(output_size=(n_rows, n_cols), name=name+'bilinear')(g) \n g = self.Conv2DTranspose_Block(g, 2, strides=1, activation='tanh', k_size=k_size, name=name+'4', bn=False)\n\n model = Model(inputs=[input_layer], outputs=[g], name='Generator')\n if (summary):\n model.summary()\n return model","def MeshMachine(main):\n\n # oDesign definition\n oDesign = main['ANSYS']['oDesign']\n\n # Data for the rotor mesh\n RotorName = main['ANSYS']['Rotor&Magnets']['Name'][0]\n RotorNumMaxElem = main['ANSYS']['Mesh']['Rotor']['NumMaxElem']\n RotorMaxLength = main['ANSYS']['Mesh']['Rotor']['MaxLength']\n\n # Data for the magnets mesh\n PMNames = main['ANSYS']['Rotor&Magnets']['PMNames']\n PMNumMaxElem = main['ANSYS']['Mesh']['Magnets']['NumMaxElem']\n PMMaxLength = main['ANSYS']['Mesh']['Magnets']['MaxLength']\n\n # Data for the Stator mesh\n StatorName = main['ANSYS']['Stator']['Name']\n StatorNormalDev = main['ANSYS']['Mesh']['Stator']['NormalDev']\n StatorAspectRatio = main['ANSYS']['Mesh']['Stator']['AspectRatio']\n\n # Data for the Stator mesh\n CoilNames = main['ANSYS']['Winding']['CoilNames']\n WindingNumMaxElem = main['ANSYS']['Mesh']['Winding']['NumMaxElem']\n WindingMaxLength = main['ANSYS']['Mesh']['Winding']['MaxLength']\n\n WindingName = []\n for phase in CoilNames:\n for direction in phase:\n WindingName += direction\n\n # Creating meshes\n oModule = oDesign.GetModule(\"MeshSetup\")\n\n # Rotor meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Rotor\",\n \"RefineInside:=\", True,\n \"Enabled:=\", True,\n \"Objects:=\", [RotorName],\n \"RestrictElem:=\", False,\n \"NumMaxElem:=\", str(RotorNumMaxElem),\n \"RestrictLength:=\", True,\n \"MaxLength:=\", str(RotorMaxLength)+\"mm\"\n ]\n )\n # Magnet meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Magnets\",\n \"RefineInside:=\", True,\n \"Enabled:=\", True,\n \"Objects:=\", PMNames,\n \"RestrictElem:=\", False,\n \"NumMaxElem:=\", str(PMNumMaxElem),\n \"RestrictLength:=\", True,\n \"MaxLength:=\", str(PMMaxLength)+\"mm\"\n ]\n )\n # Stator meshes\n oModule.AssignTrueSurfOp(\n [\n \"NAME:Stator\",\n \"Objects:=\", [StatorName],\n \"CurvedSurfaceApproxChoice:=\", \"ManualSettings\",\n \"SurfDevChoice:=\", 0,\n \"NormalDevChoice:=\", 2,\n \"NormalDev:=\", str(StatorNormalDev) + \"deg\",\n \"AspectRatioChoice:=\", 2,\n \"AspectRatio:=\", str(StatorAspectRatio)\n ]\n )\n\n # Coil meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Coils\",\n \"RefineInside:=\"\t, True,\n \"Enabled:=\"\t\t, True,\n \"Objects:=\"\t\t, WindingName,\n \"RestrictElem:=\"\t, False,\n \"NumMaxElem:=\"\t\t, str(WindingNumMaxElem),\n \"RestrictLength:=\"\t, True,\n \"MaxLength:=\"\t\t, str(WindingMaxLength) +\"mm\"\n ]\n )\n\n return main","def build_mat(self):\n for row, s in enumerate(self.S):\n for col, t in enumerate(self.T):\n\n if self.symmetric and row > col:\n pass\n\n else:\n self.mat[row, col] = self.kernel(s, t, self.n)\n\n if self.symmetric:\n self.mat = self.symmetrize(self.mat)\n else:\n for idx, s in enumerate(self.S):\n self.test_normalization[idx] = self.kernel(s, s, self.n)","def build(classes):\n # data input\n data = mx.sym.Variable(\"data\")\n\n # Block #1: first CONV => RELU => POOL layer set\n conv1_1 = mx.sym.Convolution(data=data, kernel=(11, 11), stride=(4, 4), num_filter=96)\n act1_1 = mx.sym.LeakyReLU(data=conv1_1, act_type=\"elu\")\n bn1_1 = mx.sym.BatchNorm(data=act1_1)\n pool1 = mx.sym.Pooling(data=bn1_1, pool_type=\"max\", kernel=(3, 3), stride=(2, 2))\n do1 = mx.sym.Dropout(data=pool1, p=0.25)\n\n # Block #2: second CONV => RELU => POOL layer set\n conv2_1 = mx.sym.Convolution(data=do1, kernel=(5, 5), pad=(2, 2), num_filter=256)\n act2_1 = mx.sym.LeakyReLU(data=conv2_1, act_type=\"elu\")\n bn2_1 = mx.sym.BatchNorm(data=act2_1)\n pool2 = mx.sym.Pooling(data=bn2_1, pool_type=\"max\", kernel=(3, 3), stride=(2, 2))\n do2 = mx.sym.Dropout(data=pool2, p=0.25)\n\n # Block #3: (CONV => RELU) * 3 => POOL\n conv3_1 = mx.sym.Convolution(data=do2, kernel=(3, 3), pad=(1, 1), num_filter=384)\n act3_1 = mx.sym.LeakyReLU(data=conv3_1, act_type=\"elu\")\n bn3_1 = mx.sym.BatchNorm(data=act3_1)\n conv3_2 = mx.sym.Convolution(data=bn3_1, kernel=(3, 3), pad=(1, 1), num_filter=384)\n act3_2 = mx.sym.LeakyReLU(data=conv3_2, act_type=\"elu\")\n bn3_2 = mx.sym.BatchNorm(data=act3_2)\n conv3_3 = mx.sym.Convolution(data=bn3_2, kernel=(3, 3), pad=(1, 1), num_filter=256)\n act3_3 = mx.sym.LeakyReLU(data=conv3_3, act_type=\"elu\")\n bn3_3 = mx.sym.BatchNorm(data=act3_3)\n pool3 = mx.sym.Pooling(data=bn3_3, pool_type=\"max\", kernel=(3, 3), stride=(2, 2))\n do3 = mx.sym.Dropout(data=pool3, p=0.25)\n\n # Block #4: first set of FC => RELU layers\n flatten = mx.sym.Flatten(data=do3)\n fc1 = mx.sym.FullyConnected(data=flatten, num_hidden=4096)\n act4_1 = mx.sym.LeakyReLU(data=fc1, act_type=\"elu\")\n bn4_1 = mx.sym.BatchNorm(data=act4_1)\n do4 = mx.sym.Dropout(data=bn4_1, p=0.5)\n\n # Block #5: second set of FC => RELU layers\n fc2 = mx.sym.FullyConnected(data=do4, num_hidden=4096)\n act5_1 = mx.sym.LeakyReLU(data=fc2, act_type=\"elu\")\n bn5_1 = mx.sym.BatchNorm(data=act5_1)\n do5 = mx.sym.Dropout(data=bn5_1, p=0.5)\n\n # softmax classifier\n fc3 = mx.sym.FullyConnected(data=do5, num_hidden=classes)\n model = mx.sym.SoftmaxOutput(data=fc3, name=\"softmax\")\n\n # return the network architecture\n return model","def generate_tiles(self):\n if self.children:\n for child in self.children:\n child.generate_tiles()\n print \"Generating tile for %s using child tiles\" % self.bbox\n self.generate_tile_from_child_tiles()\n else:\n print \"Generating tile for %s using source data\" % self.bbox\n self.generate_tile_from_source()","def drawMatrix(self,screen,pos):\n bp = pos # base position bp\n namesurface = myfont.render(self.parentname, False, self.parentcolour)\n screen.blit(namesurface,(bp[0]-50,bp[1] -60),) \n tempOffset = namesurface.get_width()\n namesurface = myfont.render(self.name, False, self.colour)\n screen.blit(namesurface,(bp[0]-40 ,bp[1]-30),) \n size = 10\n separationx = 12\n separationy = 20\n # Cycle through array of inputs\n for i in range(self.dimensions[0]):\n # Create red - green colour based on array\n temp_colour = (int((1-self.scan[i])*240),int(self.scan[i]*240),0)\n # Draw square that is slightly offset of previous square\n pygame.draw.rect(screen,temp_colour ,(bp[0] - separationx *int(i / len(self.inputdistance)),\n bp[1] - separationx*(i%len(self.inputdistance)) + 3*separationx,size,size))\n # Calculate intermediate decision array\n temp_vector = self.scan \n # Repeat\n for j, bs in enumerate(self.bias):\n temp_vector = np.add(temp_vector.dot(self.weights[j]), bs)\n for i in range(temp_vector.shape[0]):\n temp_colour = (int(max(min((1-temp_vector[i])*240,240),0)),int(max(min(temp_vector[i]*240,240),0)),0)\n pygame.draw.rect(screen,temp_colour ,(bp[0] + (j+1)*separationy,bp[1] + separationx*i,size,size))","def _make_random_matrix(self, n_components, n_features):","def _build_matrix(self, image):\n offset_generator = self._iter_images_rects()\n count = 1\n for src_image in self._iter_images():\n pos_x, pos_y, max_w, max_h = next(offset_generator)\n src_image, width, height = self._image_resize_keep_ratio(src_image, max_w, max_h, self._crop)\n # Adjust position to have identical margin between borders and images\n if len(self._images) < 4:\n pos_x, pos_y = pos_x + (max_w - width) // 2, pos_y + (max_h - height) // 2\n elif count == 1:\n pos_x, pos_y = pos_x + (max_w - width) * 2 // 3, pos_y + (max_h - height) * 2 // 3\n elif count == 2:\n pos_x, pos_y = pos_x + (max_w - width) // 3, pos_y + (max_h - height) * 2 // 3\n elif count == 3:\n pos_x, pos_y = pos_x + (max_w - width) * 2 // 3, pos_y + (max_h - height) // 3\n else:\n pos_x, pos_y = pos_x + (max_w - width) // 3, pos_y + (max_h - height) // 3\n\n self._image_paste(src_image, image, pos_x, pos_y)\n count += 1\n return image","def compile(self):\n self.train = self._make_train()\n self.loss_test = self._make_loss_test()\n self.predict = self._make_predict()","def generate():","def setUp(self):\r\n self.matrix = array(\r\n [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])\r\n self.cells = [(0, 1), (1, 3)]\r\n self.cells2 = [(0, 2), (2, 3)]","def generate(self):","def gen_matrix(e):\n\tif e < 1:\n\t\treturn None\n\tm_list = [[[1, 2], [3, 0]]]\n\t_b = m_list[0]\n\tfor n in xrange(1, e):\n\t\tm = m_list[n - 1]\n\t\tm_list.append(\n\t\t\t[\n\t\t\t\t[4 * i + _b[0][0] for i in m[0]] + [4 * i + _b[0][1] for i in m[0]],\n\t\t\t\t[4 * i + _b[0][0] for i in m[1]] + [4 * i + _b[0][1] for i in m[1]],\n\t\t\t\t[4 * i + _b[1][0] for i in m[0]] + [4 * i + _b[1][1] for i in m[0]],\n\t\t\t\t[4 * i + _b[1][0] for i in m[1]] + [4 * i + _b[1][1] for i in m[1]],\n\t\t\t]\n\t\t)\n\treturn m_list","def _initializeMatrices(self):\n K = self.K \n # Initialize Initia\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\n rand_initial_prob = list(rand_initial_prob[0,:])\n for i in range(K): \n self.state_initial_prob[i+1] = rand_initial_prob[i]\n\n # Initialize the transition MAtrix !\n for i in range(K):\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\n rand_initial_prob = list(rand_initial_prob[0,:]) \n\n for j in range(K):\n self.state_transition_mat[(j+1,i+1)] = rand_initial_prob[j]\n\n\n # Initialize the symbol distribution Parameters ui and si (Assuming a numeric outputs ! Modelled using a gaussian ! withmean ui and std si)\n init_mean = np.mean(self.data_matrix)\n init_std = np.std(self.data_matrix) \n \n for i in range(K):\n random_mean = gauss(init_mean,30)\n random_std = gauss(init_std,30)\n self.state_symbol_prob[i+1] = {'mean':random_mean, 'std' : random_std}","def create_output_matrix_files(self, year, max_zone_id):\r\n from opus_emme2.travel_model_output import TravelModelOutput\r\n tm_output = TravelModelOutput(self.emme_cmd)\r\n year_config = self.config['travel_model_configuration'][year]\r\n for x in 1,2,3:\r\n if \"bank%i\" % x in year_config['matrix_variable_map']:\r\n bank_dir = self.get_emme2_dir(year, \"bank%i\" % x)\r\n for matrix_name in year_config['matrix_variable_map'][\"bank%i\" % x].keys():\r\n tm_output._get_matrix_into_data_file(matrix_name, max_zone_id, bank_dir, \"%s_one_matrix.txt\" % matrix_name)","def build_layers(self):\n raise NotImplementedError","def make_input_map(self) :\n\n self.input_map = \"\"\n stencil = self.core.stencil\n pattern = self.core.pattern\n reflect = len(pattern)+1 # reflector id, last material\n N = self.dimension\n coremap = np.zeros((N+2,N+2), dtype='i')\n \n # reflections and vacuum\n coremap[0, 1:N+1] = -1 \n coremap[1:N+1, 0] = -1\n coremap[N+1, 1:N+1] = -2\n coremap[1:N+1, N+1] = -2\n \n fuelindex = 0\n \n for i in range(1, N+1) :\n for j in range(1, N+1) :\n if j == 1 and i > 1 :\n pass\n else :\n if stencil[i-1, j-1] > 0 : # a fuel\n coremap[i, j] = pattern[fuelindex]+1\n fuelindex += 1\n elif stencil[i-1, j-1] == 0 : # a reflector\n coremap[i, j] = reflect\n else : # a void\n pass \n # Copy elements such that rotational symmetry is enforced. \n for j in range(2, N+1) :\n coremap[j, 1] = coremap[1, j]\n for i in range(0, N+2) :\n for j in range(0, N+2) :\n self.input_map +='%4i' % (coremap[i, j])\n self.input_map += '\\n'","def _init_model(self):\n self.A_inv = np.zeros(shape=(self.numUsers, self.d, self.d))\n self.b = np.zeros(shape=(self.numUsers, self.d))\n self.w = np.zeros(shape=(self.numUsers, self.d))\n for i, mat in enumerate(self.A_inv):\n self.A_inv[i] = np.eye(self.d)","def build(self):\n\n self.W_AA = self.init([self.n_atom_input_feat, self.n_hidden_AA])\n self.b_AA = model_ops.zeros(shape=[\n self.n_hidden_AA,\n ])\n\n self.W_PA = self.init([self.n_pair_input_feat, self.n_hidden_PA])\n self.b_PA = model_ops.zeros(shape=[\n self.n_hidden_PA,\n ])\n\n self.W_A = self.init([self.n_hidden_A, self.n_atom_output_feat])\n self.b_A = model_ops.zeros(shape=[\n self.n_atom_output_feat,\n ])\n\n self.trainable_weights = [\n self.W_AA, self.b_AA, self.W_PA, self.b_PA, self.W_A, self.b_A\n ]\n if self.update_pair:\n self.W_AP = self.init([self.n_atom_input_feat * 2, self.n_hidden_AP])\n self.b_AP = model_ops.zeros(shape=[\n self.n_hidden_AP,\n ])\n\n self.W_PP = self.init([self.n_pair_input_feat, self.n_hidden_PP])\n self.b_PP = model_ops.zeros(shape=[\n self.n_hidden_PP,\n ])\n\n self.W_P = self.init([self.n_hidden_P, self.n_pair_output_feat])\n self.b_P = model_ops.zeros(shape=[\n self.n_pair_output_feat,\n ])\n\n self.trainable_weights.extend(\n [self.W_AP, self.b_AP, self.W_PP, self.b_PP, self.W_P, self.b_P])","def _build(self):\n with tf.variable_scope (self.name + '_architecutre') as scope:\n images_square = unflatten_layer ( self.images )\n visualize_images(images_square)\n\n # Conv Layer 1\n conv1_out, params = conv_2d_layer ( input = images_square,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n name = 'enc_conv_1',\n visualize = True )\n process_params(params, name = self.name)\n e1_params = params\n pool1_out = max_pool_2d_layer ( input = conv1_out, name = 'enc_pool_1')\n # lrn1_out = local_response_normalization_layer (pool1_out, name = 'lrn_1' )\n\n # Conv Layer 2\n conv2_out, params = conv_2d_layer ( input = pool1_out,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n name = 'enc_conv_2' )\n process_params(params, name = self.name)\n e2_params = params\n pool2_out = max_pool_2d_layer ( input = conv2_out, name = 'enc_pool_2')\n # lrn2_out = local_response_normalization_layer (pool2_out, name = 'lrn_2' )\n\n flattened = flatten_layer(pool2_out)\n\n # Dropout Layer 1 \n flattened_dropout = dropout_layer ( input = flattened,\n prob = self.dropout_prob,\n name = 'enc_dropout_1') \n\n # Dot Product Layer 1\n fc1_out, params = dot_product_layer ( input = flattened_dropout,\n neurons = HIDDEN_1,\n name = 'enc_dot_1')\n process_params(params, name = self.name)\n e3_params = params \n\n # Dropout Layer 2 \n fc1_out_dropout = dropout_layer ( input = fc1_out,\n prob = self.dropout_prob,\n name = 'enc_dropout_2')\n # Dot Product Layer 2\n fc2_out, params = dot_product_layer ( input = fc1_out_dropout, \n neurons = HIDDEN_2,\n name = 'enc_dot_2')\n process_params(params, name = self.name)\n e4_params = params \n\n # Dropout Layer 3 \n fc2_out_dropout = dropout_layer ( input = fc2_out,\n prob = self.dropout_prob,\n name = 'enc_dropout_3')\n \n # Dot Product Layer 2\n self.codeword, params = dot_product_layer ( input = fc2_out_dropout, \n neurons = CODEWORD_LENGTH,\n activation = CODE_ACTIVATION,\n name = 'enc_dot_2')\n process_params(params, name = self.name)\n process_codeword_normalization_regularizer(self.codeword, \n coeff = AUTOENCODER_CODEWORD_COEFF,\n name = self.name)\n e5_params = params \n # tf.summary.histogram('codewords', self.codeword)\n # self.hash = threshold_layer ( input = self.codeword,\n # name = 'hash')\n # process_hash_regularizer(self.codeword, coeff = AUTOENCODER_HASH_COEFF,\n # name = self.name)\n\n # Decoder ... \n decoder_1_out, params = dot_product_layer ( input = self.codeword, \n neurons = HIDDEN_2,\n params = [tf.transpose(e5_params[0]), None],\n name = 'decoder_dot_1')\n d1_params = params\n process_params([params[1]], name = self.name)\n \n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\n prob = self.dropout_prob,\n name = 'dec_dropout_1')\n\n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \n neurons = HIDDEN_1,\n params = [tf.transpose(e4_params[0]), None],\n name = 'decoder_dot_2')\n d2_params = params\n process_params([params[1]], name = self.name)\n \n # dropout 2\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\n prob = self.dropout_prob,\n name = 'dec_dropout_2')\n\n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \n neurons = 1250,\n params = [tf.transpose(e3_params[0]), None],\n name = 'decoder_dot_3')\n d3_params = params\n process_params([params[1]], name = self.name)\n\n # DeConv Layer 1\n # The output shapes need to be changed according to architecture.\n\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N )\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), name = 'dec_upsampling_1')\n\n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\n neurons = CONV_1_N,\n filter_size = CONV_2_FILT,\n output_shape = (12,12),\n # n_outs = MINI_BATCH_SIZE,\n stride = (1,1,1,1), \n params = [e2_params[0], None], \n name = 'dec_deconv_1' )\n\n process_params([params[1]], name = self.name)\n d4_params = params\n\n # DeConv Layer 2\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), name = 'dec_upsampling_2')\n decoded_images_square, params = deconv_2d_layer ( input = upsample_2,\n neurons = 1,\n filter_size = CONV_1_FILT,\n stride = (1,1,1,1),\n output_shape = (28,28),\n # n_outs = MINI_BATCH_SIZE, \n params = [e1_params[0], None], \n activation = 'tanh', \n name = 'dec_deconv_2' )\n \n process_params([params[1]], name = self.name)\n d5_params = params \n \n self.decoded = flatten_layer (decoded_images_square, in_shp = [-1, 28, 28, 1])\n visualize_images(decoded_images_square, name = 'decoded')\n # This is because transpose don't initialize.\n self.params = [ [e5_params[0], d1_params[1] ],\n [e4_params[0], d2_params[1] ],\n [e3_params[0], d3_params[1] ],\n [e2_params[0], d4_params[1] ],\n [e1_params[0], d5_params[1] ] ]\n\n with tf.variable_scope (self.name + '_objectives') as scope: \n with tf.variable_scope( self.name + '_decoder_error') as scope:\n reconstruction_error = rmse(self.images, self.decoded) \n tf.add_to_collection( self.name + '_objectives', reconstruction_error ) \n tf.summary.scalar('reconstruction_error', reconstruction_error)\n\n self._cook_optimizer( \n lr = AUTOENCODER_LR, \n optimizer = AUTOENCODER_OPTIMIZER,\n l1_coeff = AUTOENCODER_L1_COEFF,\n l2_coeff = AUTOENCODER_WEIGHT_DECAY_COEFF)","def _init_layers(self) -> None:\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\n self.cross_attn = MultiheadAttention(**self.cross_attn_cfg)\n self.embed_dims = self.self_attn.embed_dims\n self.ffn = FFN(**self.ffn_cfg)\n norms_list = [\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\n for _ in range(3)\n ]\n self.norms = ModuleList(norms_list)","def build(self):\n\n self.W = self.init([self.n_atom_input_feat, self.n_output])\n self.b = model_ops.zeros(shape=[\n self.n_output,\n ])\n\n self.trainable_weights = self.W + self.b","def generate_mos(laygen, objectname_pfix, placement_grid, routing_grid_m1m2, devname_mos_boundary, devname_mos_body,\n devname_mos_dmy, m=1, m_dmy=0, origin=np.array([0,0])):\n pg = placement_grid\n rg12 = routing_grid_m1m2\n pfix = objectname_pfix\n\n # placement\n imbl0 = laygen.relplace(name=\"I\" + pfix + 'BL0', templatename=devname_mos_boundary, gridname=pg, xy=origin)\n refi=imbl0\n if not m_dmy==0:\n imdmyl0 = laygen.relplace(name=\"I\" + pfix + 'DMYL0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\n refi=imdmyl0\n else:\n imdmyl0 = None\n im0 = laygen.relplace(name=\"I\" + pfix + '0', templatename=devname_mos_body, gridname=pg, refobj=refi, shape=[m, 1])\n refi=im0\n if not m_dmy==0:\n imdmyr0 = laygen.relplace(name=\"I\" + pfix + 'DMYR0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\n refi=imdmyr0\n else:\n imdmyr0 = None\n imbr0 = laygen.relplace(name=\"I\" + pfix + 'BR0', templatename=devname_mos_boundary, gridname=pg, refobj=imdmyr0)\n md=im0.elements[:, 0]\n #route\n #gate\n rg0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['G0'], refobj1=md[-1].pins['G0'])\n for _md in md:\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['G0'], gridname=rg12)\n #drain\n rdl0=laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=md[0].pins['D0'], refobj1=md[-1].pins['D0'])\n for _md in md:\n laygen.via(name=None, xy=[0, 1], refobj=_md.pins['D0'], gridname=rg12)\n #source\n rs0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['S0'], refobj1=md[-1].pins['S1'])\n for _md in md:\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['S0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=md[-1].pins['S1'], gridname=rg12)\n #dmy\n if m_dmy>=2:\n mdmyl=imdmyl0.elements[:, 0]\n mdmyr=imdmyr0.elements[:, 0]\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyl[0].pins['D0'], refobj1=mdmyl[-1].pins['D0'])\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyr[0].pins['D0'], refobj1=mdmyr[-1].pins['D0'])\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyl[0].pins['S0'], refobj1=mdmyl[-1].pins['S1'])\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyr[0].pins['S0'], refobj1=mdmyr[-1].pins['S1'])\n for _mdmyl in mdmyl:\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyl.pins['D0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyl.pins['S0'], gridname=rg12)\n for _mdmyr in mdmyr:\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyr.pins['D0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyr.pins['S1'], gridname=rg12)\n return [imbl0, imdmyl0, im0, imdmyr0, imbr0]","def generate_features(self):\n content_input = self.content_image * 255\n style_input = self.style_image * 255\n preprocessed_content = tf.keras.applications.vgg19.preprocess_input(\n content_input)\n preprocessed_style = tf.keras.applications.vgg19.preprocess_input(\n style_input)\n outputs_content = self.model(preprocessed_content)\n outputs_style = self.model(preprocessed_style)\n\n num_style_layers = tf.size(self.style_layers)\n style_outputs, content_outputs = (\n outputs_style[:num_style_layers],\n outputs_content[num_style_layers:])\n\n style_outputs = [self.gram_matrix(\n style_output)for style_output in style_outputs]\n self.gram_style_features = style_outputs\n self.content_feature = content_outputs","def initialize_matrices(self):\n assert self._training_dataset and self._valid_dataset\n # inject prior knowledge about transition and emission\n self._state_prior = torch.zeros(self._config.d_hidden, device=self._config.device) + 1e-2\n self._state_prior[0] += 1 - self._state_prior.sum()\n\n intg_obs = list(map(np.array, self._training_dataset.obs + self._valid_dataset.obs))\n self._trans_mat = torch.tensor(initialise_transmat(\n observations=intg_obs, label_set=self._config.bio_label_types)[0], dtype=torch.float)\n self._emiss_mat = torch.tensor(initialise_emissions(\n observations=intg_obs, label_set=self._config.bio_label_types,\n sources=self._config.sources, src_priors=self._config.src_priors\n )[0], dtype=torch.float)\n return self","def _build(self, z, targets= None, input_params = None):\n with tf.variable_scope (self.name + '_architecture') as scope:\n with tf.variable_scope ( 'generator') as scope:\n self.z = z\n self.targets =targets\n\n # Dot Product Layer 1\n par = input_params[0]\n process_params(par, name = self.name) \n par[0] = tf.transpose(par[0]) \n # Decoder ... \n decoder_1_out, params = dot_product_layer ( input = self.z, \n neurons = HIDDEN_2,\n params = par,\n name = 'gen_decoder_dot_1')\n g1_params = params\n \n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\n prob = self.dropout_prob,\n name = 'gen_dropout_1')\n\n # Dot Product Layer 2 \n par = input_params[1]\n process_params(par, name = self.name) \n par[0] = tf.transpose(par[0]) \n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \n neurons = HIDDEN_1,\n params = par,\n name = 'gen_decoder_dot_2')\n g2_params = params\n\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\n prob = self.dropout_prob,\n name = 'gen_dropout_2')\n\n # Dot Product Layer 3 \n par = input_params[2]\n process_params(par, name = self.name) \n par[0] = tf.transpose(par[0]) \n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \n neurons = 1250,\n params = par,\n name = 'gen_decoder_dot_0')\n g3_params = params\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N,\n name = 'gen_unflatten' )\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), \n name = 'gen_upsampling_1')\n\n # Convolution layer 1\n par = input_params[3]\n process_params(par, name = self.name) \n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\n neurons = CONV_1_N,\n filter_size = CONV_2_FILT,\n output_shape = (12,12),\n params = par, \n name = 'deconv_1' )\n\n g4_params = params\n\n # DeConv Layer 2\n par = input_params[4]\n process_params(par, name = self.name)\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), \n name = 'gen_upsampling_2')\n generated_images_square, params = deconv_2d_layer ( \n input = upsample_2,\n neurons = 1,\n filter_size = CONV_1_FILT,\n stride = (1,1,1,1),\n output_shape = (28,28),\n params = par, \n activation = 'tanh', \n name = 'conv_2' )\n \n g5_params = params\n self.generation = flatten_layer (generated_images_square, in_shp = [-1, 28, 28, 1])\n visualize_images(generated_images_square, name = 'generated_images')\n self.params = [g1_params, g2_params, g3_params, g4_params, g5_params]","def _build_forward_graph(self):\n\n print('[*] Building a Neural Turing Machine.')\n\n self._initalize_state()\n\n # present start token\n controller_out = self.controller.emit_feature_vector(self.start_token, self.r_t[0], reuse=None)\n self._read_write(controller_out, reuse=None)\n\n # present inputs\n print('Input chain: ')\n for t in range(0, self.sequence_length):\n print_progress(float(t + 1) / self.sequence_length)\n\n controller_out = self.controller.emit_feature_vector(self.inputs[t], self.r_t[-1], reuse=True)\n self._read_write(controller_out, reuse=True)\n\n # present end token\n controller_out = self.controller.emit_feature_vector(self.end_token, self.r_t[-1], reuse=True)\n self._read_write(controller_out, reuse=True)\n\n # present outputs\n print('Output chain: ')\n for t in range(0, self.sequence_length):\n print_progress(float(t + 1) / self.sequence_length)\n\n controller_out = self.controller.emit_feature_vector(self.zeros, self.r_t[-1], reuse=True)\n self._read_write(controller_out, reuse=True)\n\n reuse = None if t == 0 else True\n self.outputs.append(self._decode_read_vector(self.r_t[-1], reuse=reuse))\n print('Done.')","def _build_all_models(self):\r\n self.output_tensors = {}\r\n self.loss_terms = {}\r\n self.metrics = {}\r\n\r\n def _build_datasource_summaries(data_sources, mode):\r\n \"\"\"Register summary operations for input data from given data sources.\"\"\"\r\n with tf.variable_scope('%s_data' % mode):\r\n for data_source_name, data_source in data_sources.items():\r\n tensors = data_source.output_tensors\r\n for key, tensor in tensors.items():\r\n summary_name = '%s/%s' % (data_source_name, key)\r\n shape = tensor.shape.as_list()\r\n num_dims = len(shape)\r\n if num_dims == 4: # Image data\r\n if shape[1] == 1 or shape[1] == 3:\r\n self.summary.image(summary_name, tensor,\r\n data_format='channels_first')\r\n elif shape[3] == 1 or shape[3] == 3:\r\n self.summary.image(summary_name, tensor,\r\n data_format='channels_last')\r\n # TODO: fix issue with no summary otherwise\r\n elif num_dims == 2:\r\n self.summary.histogram(summary_name, tensor)\r\n else:\r\n logger.debug('I do not know how to create a summary for %s (%s)' %\r\n (summary_name, tensor.shape.as_list()))\r\n\r\n def _build_train_or_test(mode):\r\n data_sources = self._train_data if mode == 'train' else self._test_data\r\n\r\n # Build model\r\n output_tensors, loss_terms, metrics = self.build_model(data_sources, mode=mode)\r\n\r\n # Record important tensors\r\n self.output_tensors[mode] = output_tensors\r\n self.loss_terms[mode] = loss_terms\r\n self.metrics[mode] = metrics\r\n\r\n # Create summaries for scalars\r\n if mode == 'train':\r\n for name, loss_term in loss_terms.items():\r\n self.summary.scalar('loss/%s/%s' % (mode, name), loss_term)\r\n for name, metric in metrics.items():\r\n self.summary.scalar('metric/%s/%s' % (mode, name), metric)\r\n\r\n # Build the main model\r\n if len(self._train_data) > 0:\r\n _build_datasource_summaries(self._train_data, mode='train')\r\n _build_train_or_test(mode='train')\r\n logger.info('Built model.')\r\n\r\n # Print no. of parameters and lops\r\n flops = tf.profiler.profile(\r\n options=tf.profiler.ProfileOptionBuilder(\r\n tf.profiler.ProfileOptionBuilder.float_operation()\r\n ).with_empty_output().build())\r\n logger.info('------------------------------')\r\n logger.info(' Approximate Model Statistics ')\r\n logger.info('------------------------------')\r\n logger.info('FLOPS per input: {:,}'.format(flops.total_float_ops / self._batch_size))\r\n logger.info(\r\n 'Trainable Parameters: {:,}'.format(\r\n np.sum([np.prod(v.shape.as_list()) for v in tf.trainable_variables()])\r\n )\r\n )\r\n logger.info('------------------------------')\r\n\r\n # If there are any test data streams, build same model with different scope\r\n # Trainable parameters will be copied at test time\r\n if len(self._test_data) > 0:\r\n _build_datasource_summaries(self._test_data, mode='test')\r\n with tf.variable_scope('test'):\r\n _build_train_or_test(mode='test')\r\n logger.info('Built model for live testing.')\r\n\r\n if self._enable_live_testing:\r\n self._tester._post_model_build() # Create copy ops to be run before every test run\r","def construct(self):\n self.input_size = self.numplanes * self.boardsize**2\n \n if self.hidden:\n layers = [\n torch.nn.Linear(self.input_size, self.hidden), \n torch.nn.ReLU(),\n torch.nn.Linear(self.hidden, self.boardsize**2)\n ]\n else:\n layers = [torch.nn.Linear(self.input_size, self.boardsize**2)]\n\n self.layers = torch.nn.ModuleList(layers)\n self.optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)\n logging.info(\"Model initialized: %s\", self)","def main():\n g = CommanderGame([4, 3], 3)\n g.fit_army_orders()\n g.fit_game_matrix()\n g.show_submatrixes([\n [[4, 0, 0]],\n [[2, 1, 0], [1, 1, 1]],\n ])\n print(f'Full game matrix: \\n{g.game_matrix_}')","def process(self, mat):","def main():\n num_schedules = 150\n trainer = AutoEncoderTrain(num_schedules)\n trainer.train()\n trainer.compute_mean()\n trainer.create_iterables()\n\n trainer.round_each_encoding_and_create_array()\n trainer.populate_a_matrix_per_schedule()\n trainer.save_matrixes()","def matrix_generation(self, matrix_size, generate_to):\n matrix_A = np.random.randint(generate_to, size=(matrix_size, matrix_size))\n matrix_B = np.random.randint(generate_to, size=(matrix_size, matrix_size))\n # print(matrix_A)\n # print(matrix_B)\n # print(np.matmul(matrix_A, matrix_B))\n matrices = (matrix_A, matrix_B)\n return matrices","def compile(self):\n m, n = self.input_shape[1], self.input_shape[2]\n\n inp = Input(shape=self.input_shape, traces=True)\n self.add_layer(inp, \"DoG\")\n\n s1 = LIFNodes(shape=(18, m, n), traces=True)\n self.add_layer(s1, \"conv_1\")\n c1 = LIFNodes(shape=(18, m // 2, n // 2), traces=True)\n self.add_layer(c1, \"pool_1\")\n\n s2 = LIFNodes(shape=(24, m // 2, n // 2), traces=True)\n self.add_layer(s2, \"conv_2\")\n c2 = LIFNodes(shape=(24, m // 4, n // 4), traces=True)\n self.add_layer(c2, \"pool_2\")\n\n s3 = LIFNodes(shape=(32, m // 4, n // 4), traces=True)\n self.add_layer(s3, \"conv_3\")\n f = LIFNodes(shape=(32, 1), traces=True)\n self.add_layer(f, \"global_pool\")\n\n conv1 = Conv2dConnection(inp, s1, 5, padding=2, weight_decay=0.01,\n nu=0.01, update_rule=PostPre, decay=0.5)\n self.add_connection(conv1, \"DoG\", \"conv_1\")\n pool1 = MaxPool2dConnection(s1, c1, 2, 2, decay=0.5)\n self.add_connection(pool1, \"conv_1\", \"pool_1\")\n\n conv2 = Conv2dConnection(c1, s2, 3, padding=1, weight_decay=0.01,\n nu=0.01, update_rule=PostPre, decay=0.5)\n self.add_connection(conv2, \"pool_1\", \"conv_2\")\n pool2 = MaxPool2dConnection(s2, c2, 2, 2, decay=0.5)\n self.add_connection(pool2, \"conv_2\", \"pool_2\")\n\n conv3 = Conv2dConnection(c2, s3, 3, padding=1, weight_decay=0.01,\n nu=0.01, update_rule=PostPre, decay=0.5)\n self.add_connection(conv3, \"pool_2\", \"conv_3\")\n global_pool = MaxPool2dConnection(s3, f, (m // 4, n // 4), decay=0.5)\n self.add_connection(global_pool, \"conv_3\", \"global_pool\")\n\n monitor = NetworkMonitor(self, layers=[\"DoG\", \"conv_1\", \"pool_1\",\n \"conv_2\", \"pool_2\",\n \"conv_3\", \"global_pool\"],\n connections=[(\"DoG\", \"conv_1\"),\n (\"pool_1\", \"conv_2\"),\n (\"pool_2\", \"conv_3\")],\n state_vars=[\"w\", \"s\"])\n self.add_monitor(monitor, \"network_monitor\")\n\n return self","def build_model(self):\n import tensorflow as tf\n \n y = tf.nn.relu(tf.matmul(self.variables[\"input_observation\"], self.variables[\"W1\"]) + \n self.variables[\"b1\"], name=\"y1\")\n \n for i in range(self.n_hidden-1):\n y = tf.nn.relu(tf.matmul(y, self.variables[\"W\"+str(i+2)]) + \n self.variables[\"b\"+str(i+2)], name=\"y\"+str(i+2))\n \n self.variables[\"y\"] = [tf.matmul(y, self.variables[\"Wo_0\"]) + self.variables[\"bo_0\"]]\n for i in range(1, len(self.output_size)):\n self.variables[\"y\"] += [tf.matmul(y, self.variables[\"Wo_%s\"%i]) + self.variables[\"bo_%s\"%i]]","def _export_model(self):\n graph = ComputeGraph.from_onnx(self.onnx_model.graph)\n\n print(\"Running constant propagation\")\n constant_states = constant_propagation(graph)\n\n self._remove_constants(graph, constant_states)\n self._remove_nops(graph, constant_states)\n\n # Add shape information from constant propagation:\n for var, res in constant_states.items():\n if var in graph.shape_dict:\n shape = graph.shape_dict[var]\n if res.shape != shape:\n print(\"Warning: Shapes do not match: \", var, res.shape, shape)\n if res.shape is not None:\n print(\"Replacing shape {} with {}\".format(shape, res.shape))\n graph.shape_dict[var] = res.shape\n elif res.shape is not None:\n graph.shape_dict[var] = res.shape\n\n print(\"Inference graph:\")\n for node in graph.nodes:\n inputs = node.inputs\n input_shapes = (str(graph.shape_dict[i]) for i in node.inputs if i in graph.shape_dict)\n outputs = node.outputs\n output_shapes = (str(graph.shape_dict[o]) for o in node.outputs if o in graph.shape_dict)\n print(\"{:<24} {:<20} {:<30} {:<30} {:<20} {:<30}\".format(node.name,\n node.op_type,\n \",\".join(inputs),\n \",\".join(input_shapes),\n \",\".join(outputs),\n \",\".join(output_shapes)))\n\n memory_manager = MemoryManager()\n\n self._generate_weights_file(graph)\n\n self.dummy_input = generate_dummy_main(graph)\n\n self.reference_input = generate_reference_main(graph)\n\n self._generate_network_initialization(graph, memory_manager)\n\n self._generate_network_cleanup(graph, memory_manager)\n\n implementations = self._select_implementations(graph, memory_manager)\n schedule = self._get_schedule(graph, implementations)\n # self._print_live_ranges(schedule)\n\n input_names = [\"input_\"+name.replace('.', '_').replace(':', '_').replace('/', '_')\n for name, type, shape in graph.inputs]\n output_names = [\"output_\"+name.replace('.', '_').replace(':', '_').replace('/', '_')\n for name, type, shape in graph.outputs]\n\n \"\"\"Currently we only allow single input (no batch processing) to the CNN, but this may be multi-channel input\"\"\"\n inputs = graph.inputs\n if len(inputs) > 1:\n print(\"ERROR: Multiple inputs not supported!\")\n exit(1)\n else:\n input_shape = graph.shape_dict[inputs[0].name]\n print(\"Input shape: {}\".format(input_shape))\n\n if len(input_shape) == 4:\n if input_shape[0] != 1:\n print(\"ERROR: Inference for batch_size > 1 currently not supported!\")\n exit(1)\n\n input_defs = [\"pico_cnn::naive::Tensor *\"+n for n in input_names]\n\n elif len(input_shape) == 3:\n if input_shape[0] != 1:\n print(\"ERROR: Inference for batch_size > 1 currently not supported!\")\n exit(1)\n\n input_defs = [\"pico_cnn::naive::Tensor *\"+n for n in input_names]\n\n elif len(input_shape) == 2:\n print(\"Input is one-dimensional (batch_size = 1 and num_input_channels = 1)\")\n input_defs = [\"pico_cnn::naive::Tensor *\"+n for n in input_names]\n\n outputs = graph.outputs\n if len(outputs) > 1:\n print(\"ERROR: Multiple outputs not supported\")\n exit(1)\n else:\n output_shape = graph.shape_dict[outputs[0].name]\n print(\"Output shape: {}\".format(output_shape))\n\n if len(output_shape) == 2:\n print(\"Output is one-dimensional (batch_size = 1 and num_input_channels = 1)\")\n output_defs = [\"pico_cnn::naive::Tensor *\" + n for n in output_names]\n elif len(output_shape) == 3:\n print(\"ERROR: Unknown output shape of network: {}\".format(output_shape))\n exit(1)\n elif len(output_shape) == 4:\n print(\"ERROR: Multi-dimensional output is currently not supported.\")\n exit(1)\n\n network_def = \"void Network::run(\" + \", \".join(input_defs) + \", \" + \", \".join(output_defs) + \")\"\n network_def_header = \"void run(\" + \", \".join(input_defs) + \", \" + \", \".join(output_defs) + \")\"\n\n layer_declaration_code = \"\"\n layer_allocation_code = \"\"\n layer_execution_code = \"\"\n layer_deletion_code = \"\"\n\n \"\"\"Iterate over all tasks in the schedule, put some debug info in the code and the pico-cnn implementation.\"\"\"\n for task in schedule:\n num, node, impl = task\n layer_allocation_code += \" //Layer \" + str(num) + \" \" + node.name + \" \" + node.op_type + \"\\n\"\n layer_allocation_code += \" //Attributes\\n\"\n for key, val in node.attrs.items():\n layer_allocation_code += \" // \" + str(key) + \": \" + str(val) + \"\\n\"\n layer_allocation_code += \" //Parameters\\n\"\n layer_allocation_code += \" //Inputs: \" + \",\".join(node.inputs) + \"\\n\"\n layer_allocation_code += \" //Outputs: \" + \",\".join(node.outputs) + \"\\n\"\n layer_allocation_code += \" //Shape:\\n\"\n for i in node.inputs:\n layer_allocation_code += \" // {}: {}\\n\".format(i, graph.get_shape(i))\n for o in node.outputs:\n layer_allocation_code += \" // {}: {}\\n\".format(o, graph.get_shape(o))\n\n if impl:\n layer_declaration_code += impl.generate_declaration()\n layer_declaration_code += \"\\n\"\n\n layer_allocation_code += impl.generate_allocation()\n layer_allocation_code += \"\\n\"\n\n layer_execution_code += impl.generate_execution()\n layer_execution_code += \"\\n\"\n\n layer_deletion_code += impl.generate_deletion()\n layer_deletion_code += \"\\n\"\n\n else:\n print(\"ERROR: Unsupported layer: {}! Aborting code generation.\".format(node.op_type))\n return 1\n\n self.constructor_code += layer_allocation_code + \"\\n\"\n self.destructor_code += layer_deletion_code + \"\\n\"\n\n # # TODO: What does this loop do?\n # for id, buffer in memory_manager.buffers.items():\n # if graph.is_tensor(id):\n # continue\n # if graph.is_input(id):\n # continue\n # if graph.is_output(id):\n # continue\n\n network_code: Text = \"#include \\\"network.h\\\"\\n\\n\"\n network_code += \"Network::Network() {\\n\\n\"\n network_code += self.constructor_code + \"\\n\"\n network_code += \"}\\n\\n\"\n network_code += \"Network::~Network() {\\n\"\n network_code += self.destructor_code + \"\\n\"\n network_code += \"}\\n\\n\"\n network_code += network_def+\"{\\n\"\n network_code += layer_execution_code\n\n network_code += \"}\\n\\n\"\n\n network_header = \"#ifndef NETWORK_H\\n\"\n network_header += \"#define NETWORK_H\\n\\n\"\n network_header += \"#include \\\"pico-cnn/pico-cnn.h\\\"\\n\\n\"\n network_header += \"class Network {\\n\"\n network_header += \"public:\\n\"\n network_header += \"Network();\\n\"\n network_header += \"~Network();\\n\"\n network_header += network_def_header + \"; \\n\\n\"\n network_header += self.buffer_declaration + \"\\n\"\n network_header += layer_declaration_code\n network_header += \"};\\n\"\n network_header += \"#endif //NETWORK_H\\n\"\n\n self.network_code = network_code\n self.network_header = network_header\n\n \"\"\"\n Create Makefile containing a target for the generated dummy input and a network specific one.\n The code for the network specific input has to be written manually.\n \"\"\"\n # TODO: Does this need to be more sophisticated?\n self.makefile = \"CC = g++\\n\"\n self.makefile += \"CFLAGS = -std=c++11 -Wall -O2 -march=native -DINFO\\n\"\n self.makefile += \"LDFLAGS = -L../../../pico-cnn\\n\"\n self.makefile += \"LD_LIBS = -lpico-cnn -lm\\n\\n\"\n self.makefile += \"# list of all generated .cpp files.\\n\"\n self.makefile += \"NETWORK_LIST = network.cpp\"\n self.makefile += \"\\n\\ndummy_input: dummy_input.cpp $(NETWORK_LIST) libpico-cnn.a\\n\\t\"\n self.makefile += \"$(CC) dummy_input.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) $(LDFLAGS) $(LD_LIBS) -o dummy_input\"\n self.makefile += \"\\n\\nreference_input: reference_input.cpp $(NETWORK_LIST) libpico-cnn.a\\n\\t\"\n self.makefile += \"$(CC) reference_input.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) \" \\\n \"$(LDFLAGS) $(LD_LIBS) -o reference_input\"\n self.makefile += \"\\n\\n{}: {}.cpp $(NETWORK_LIST) libpico-cnn.a\\n\\t\".format(self.model_name, self.model_name)\n self.makefile += \"$(CC) {}.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) \" \\\n \"$(LDFLAGS) $(LD_LIBS) -o {}\".format(self.model_name, self.model_name)\n self.makefile += \"\\n\\nall: dummy_input reference_input {}\".format(self.model_name)\n self.makefile += \"\\n\\n.PHONY: clean\\n\"\n self.makefile += \"clean:\\n\\trm -rf {} dummy_input reference_input\\n\".format(self.model_name)\n self.makefile += \"\\n\\n.PHONY: libpico-cnn.a\\n\"\n self.makefile += \"libpico-cnn.a:\\n\\t$(MAKE) -C ../../../pico-cnn\"\n\n self.save(\"./generated_code/{}\".format(self.model_name))","def generateMatrix(self):\n if self.tokenWeights and self.extraFeatures:\n nFeatures = self.wordId + self.wordId2 + len(self.EXTRA_WEIGHTS_LABELS)\n logging.info('Exporting TOKEN WEIGHTS AND EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n # iterate through 1st sentence\n for wId, val in doc['s1'].iteritems():\n mtrx[docId, wId] = val\n # then iterate thru 2nd sentence, store on 2ND PARTITION\n for wId, val in doc['s2'].iteritems():\n mtrx[docId, self.wordId + wId] = val\n # finally extra features values stored at the end of the vector\n for label, val in doc['extraFeatures'].iteritems():\n mtrx[docId, self.wordId + self.wordId2 + self.EXTRA_WEIGHTS_LABELS.index(label)] = val\n\n elif self.tokenWeights and not self.extraFeatures:\n nFeatures = self.wordId + self.wordId2\n logging.info('Exporting TOKEN WEIGHTS %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n # iterate through 1st sentence\n for wId, val in doc['s1'].iteritems():\n mtrx[docId, wId] = val\n # then iterate thru 2nd sentence, store on 2ND PARTITION\n for wId, val in doc['s2'].iteritems():\n mtrx[docId, self.wordId + wId] = val\n else:\n nFeatures = len(self.EXTRA_WEIGHTS_LABELS)\n logging.info('Exporting EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n for label, val in doc['extraFeatures'].iteritems():\n mtrx[docId, self.EXTRA_WEIGHTS_LABELS.index(label)] = val\n logging.info('Matrix generated')\n logging.info(mtrx.shape)\n return mtrx","def create_start_data(self):\n\t\tdef inputMesh(feature_size):\n\t\t\tc1= np.expand_dims(np.array([0,-0.9]),0)\n\t\t\tc2= np.expand_dims(np.array([-0.9,0.9]),0)\n\t\t\tc3= np.expand_dims(np.array([0.9,0.9]),0)\n\t\t\tx1 = np.expand_dims(np.pad(np.array([0,-0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\n\t\t\tx2 = np.expand_dims(np.pad(np.array([-0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\n\t\t\tx3 = np.expand_dims(np.pad(np.array([0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\n\t\t\tedge_index = np.transpose(np.array([[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]])) # COO format\n\t\t\treturn np.concatenate((c1,c2,c3),axis=0), np.concatenate((x1,x2,x3),axis=0),edge_index\n\n\t\tc, x, edge_index = inputMesh(self.params.feature_size)# x is c with zeros appended, x=f ..pixel2mesh\n\t\tdata_list_x = []\n\t\tdata_list_c = []\n\t\tdata_list_pid = []\n\t\tfor i in range(self.params.batch_size):\n\t\t\tdata_list_x.append(Data(x=torch.Tensor(x).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\n\t\t\tdata_list_c.append(Data(x=torch.Tensor(c).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\n\t\t\tdata_list_pid.append(Data(x=torch.zeros(c.shape[0],1).type(dtypeL).requires_grad_(False)))\n\t\tbatch_x = Batch.from_data_list(data_list_x)\n\t\tbatch_c = Batch.from_data_list(data_list_c)\n\t\tbatch_pid = Batch.from_data_list(data_list_pid)\n\t\treturn batch_x, batch_c, batch_pid","def process(self):\n # Opening and preprocessing of the input file\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\n if self.options.mbtiles_fromdisk:\n i_parm=10\n if self.options.mbtiles_todisk:\n i_parm=11\n if self.options.verbose:\n print \"GDAL2MbTiles :mbtiles from/to disk [\",i_parm,\"] mbtiles_fromdisk[\",self.options.mbtiles_fromdisk,\"] mbtiles_todisk[\",self.options.mbtiles_todisk,\"]\"\n self.mbtiles_setup(i_parm)\n return\n else:\n if self.options.verbose:\n print \"GDAL2MbTiles :tile creation mbtiles[\",self.options.mbtiles,\"]\"\n self.open_input()\n # Generation of main metadata files and HTML viewers\n self.generate_metadata()\n # Generation of the lowest tiles\n self.generate_base_tiles()\n # Generation of the overview tiles (higher in the pyramid)\n self.generate_overview_tiles()\n # Generating of KML\n self.generate_kml()","def build(self, weight = 0.5):\n \n self.weight = weight\n \n # Defining weighting matrixes\n self.processing_fw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\n self.processing_bw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\n self.processing_last_ht = torch.randn((self._hidden_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\n \n # These will only be applied to the intermediate hidden states\n self.linear_fw = nn.Linear(self._seqlen - 1, 1).to(self.device)\n self.linear_bw = nn.Linear(self._seqlen - 1, 1).to(self.device)\n \n self.compression = torch.randn((self._expansion_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\n \n if self._activation_fn == 'tanh' or isinstance(self._activation_fn, torch.nn.modules.activation.Tanh):\n self._activation_fn = nn.Tanh()\n elif self._activation_fn == 'sigmoid' or isinstance(self._activation_fn, torch.nn.modules.activation.Sigmoid):\n self._activation_fn = nn.Sigmoid()\n elif self._activation_fn == 'leaky ReLU' or isinstance(self._activation_fn, torch.nn.modules.activation.LeakyReLU):\n self._activation_fn = nn.LeakyReLU()\n else:\n raise ValueError('Non-linear activation function must be \"tanh\", \"sigmoid\" or \"leaky ReLU\"')\n \n # Passing it onto the relevant device\n self._activation_fn = self._activation_fn.to(self.device)","def run(layers):","def create_modules(self):\n self.bitcell = self.replica_bitcell = self.mod_replica_bitcell()\n self.add_mod(self.bitcell)\n\n # This is the replica bitline load column that is the height of our array\n self.rbl = bitcell_array(name=\"bitline_load\", cols=1, rows=self.bitcell_loads)\n self.add_mod(self.rbl)\n\n # FIXME: The FO and depth of this should be tuned\n self.delay_chain = self.mod_delay_chain([self.delay_fanout]*self.delay_stages)\n self.add_mod(self.delay_chain)\n\n self.inv = pinv()\n self.add_mod(self.inv)\n\n self.access_tx = ptx(tx_type=\"pmos\")\n self.add_mod(self.access_tx)","def CreateDesignMatrix_X(z, x, y, n ):\n if len(x.shape) > 1:\n x = np.ravel(x)\n y = np.ravel(y)\n\n N = len(x)\n l = int((n+1)*(n+2)/2) \n X = np.ones((N,l))\n\n for i in range(1,n+1):\n q = int((i)*(i+1)/2)\n for k in range(i+1):\n X[:,q+k] = x**(i-k) * y**k\n \n X, z_, indicies = shuffle(X, z)\n X_train, X_test, z_train, z_test = train_test_split(X, z_, test_size=split_train_test, random_state=seed, shuffle=False)\n X_test, X_val, z_test, z_val = train_test_split(X_test, z_test, test_size=split_test_val, random_state=seed, shuffle=False)\n\n return X, X_train, X_test, X_val, z_train, z_test, z_val, indicies","def generate_map(self):\n\n # Create main streets first\n self.create_main_streets()\n\n # Then create the commercial buildings in the center of town\n self.create_commercial_center()\n\n # Then create the neighborhoods that populate the rest of the city\n while(self.create_neighborhood()):\n pass\n\n # Clean up any invalid buildings that were created\n self.delete_inaccessible_buildings()","def build(self):\n if self.is_built:\n return\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n #self.names = []\n self.nelements //= self.ntimes\n\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n self.node_element = np.zeros((self.ntotal, 2), dtype=idtype)\n #oxx, oyy, txy, angle, major, minor, ovm\n self.data = np.zeros((self.ntimes, self.nelements, 8), dtype=fdtype)\n self.location = np.empty(self.ntotal, dtype='U8')\n\n self._times = np.zeros(self.ntimes, dtype=dtype)","def create_grids(self):\n \n par = self.par\n\n # a. retirement\n \n # pre-decision states\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\n \n # post-decision states\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\n \n # b. working: state space (m,n,k) \n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\n\n par.Nn = par.Nm\n par.n_max = par.m_max + par.n_add\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\n\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\n\n # c. working: w interpolant (and wa and wb and wq)\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\n par.a_max = par.m_max + par.a_add\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\n \n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\n par.b_max = par.n_max + par.b_add\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\n \n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\n \n # d. working: egm (seperate grids for each segment)\n \n if par.solmethod == 'G2EGM':\n\n # i. dcon\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\n \n # ii. acon\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\n par.a_acon = np.zeros(par.grid_b_acon.shape)\n par.b_acon = par.grid_b_acon\n\n # iii. con\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\n \n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\n\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\n par.a_con = np.zeros(par.c_con.shape)\n par.d_con = np.zeros(par.c_con.shape)\n \n elif par.solmethod == 'NEGM':\n\n par.grid_l = par.grid_m\n\n # e. shocks\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\n\n if par.Neta > 1:\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\n else:\n par.eta = np.ones(1)\n par.w_eta = np.ones(1)\n\n # f. timings\n par.time_work = np.zeros(par.T)\n par.time_w = np.zeros(par.T)\n par.time_egm = np.zeros(par.T)\n par.time_vfi = np.zeros(par.T)","def _setup(self) -> None:\n #TODO: type\n self.activation = self.params['activation']\n\n self.batchsize: int = self.params['batchsize']\n\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\n\n self.d: int = self.input_shape[1]\n assert(not self.d == 0)\n\n self.n: int = int(sqrt(self.input_shape[2]))\n assert(not self.n == 0)\n\n self.dtype: type = self.params['dtype']\n\n # initialize weights\n self.W: List[tf.Tensor] = []\n \n for i in range(3):\n #TODO: type\n w_init = self.params['initializer_w']\n if self.params['initializer_w' + str(i)] is not None:\n w_init = self.params['initializer_w' + str(i)]\n\n w_stddev: float = self.params['stddev_w']\n if self.params['stddev_w' + str(i)] is not None:\n w_stddev = self.params['stddev_w' + str(i)]\n\n self.W.append(tf.get_variable(\"weights_\" + str(i),\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\n dtype = self.dtype,\n initializer = w_init(stddev=w_stddev)))\n\n #TODO: type\n b_init = self.params['initializer_b']\n b_stddev = self.params['stddev_b']\n self.B: tf.Tensor = tf.get_variable(\"biases\", shape = (1, self.d, 1),\n dtype = self.dtype,\n initializer = b_init(stddev=b_stddev))\n\n # create/load expand matrix\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\n self.expand: tf.Tensor = tf.get_variable(\n \"expand\" + str(self.n),\n shape = (self.n, self.n * self.n),\n dtype = self.dtype,\n initializer = tf.constant_initializer(make_expand(self.n)))\n\n # create/load tile matrix\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\n for i in range(1, self.n):\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\n\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)","def test_matrix_shapes(self):\n k = [2, 3, 4, 5, 6]\n mn = self.create_chain_model(k)\n\n max_states = max(k)\n\n assert mn.matrix_mode is False, \"Matrix mode flag was set prematurely\"\n\n mn.create_matrices()\n\n assert mn.matrix_mode, \"Matrix mode flag wasn't set correctly\"\n\n assert mn.unary_mat.shape == (max_states, 5)","def get_all_coding_matrices(self):\n class tran_matrix():\n def __init__(self):\n self.S = None\n self.T = None\n self.H1 = None\n self.H2 = None\n self.G1 = None\n self.G2 = None\n self.H = None\n self.H2G2 = None\n\n def __init__(self, S, T, H1, H2, G1, G2, H, H2G2):\n self.S = S\n self.T = T\n self.H1 = H1\n self.H2 = H2\n self.G1 = G1\n self.G2 = G2\n self.H = H\n self.H2G2 = H2G2\n\n s = self.sources\n s_edges = [self.out_edges(x) for x in s]\n S = [list(set(self.get_edges_indices(src))) for src in s_edges]\n\n matrices = []\n for dsts in self.dst_evolution_rec[::-1]:\n T = [sorted(x) for x in dsts]\n H2_raw = self.coding_matrix[T[0]].ix[S[1]].values\n G2_raw = self.coding_matrix[T[1]].ix[S[1]].values\n H1 = numpy_to_generic(self.coding_matrix[T[0]].ix[S[0]].values)\n H2 = numpy_to_generic(H2_raw)\n G1 = numpy_to_generic(self.coding_matrix[T[1]].ix[S[0]].values)\n G2 = numpy_to_generic(G2_raw)\n H = numpy_to_generic(self.coding_matrix[T[0]].values)\n H2G2 = numpy_to_generic(np.hstack((H2_raw, G2_raw)))\n temp = tran_matrix(S, T, H1, H2, G1, G2, H, H2G2)\n matrices.append(temp)\n\n return matrices","def main(self):\n if self.mode==0: #drawing\n self.draw()\n self.graph_drawing=self.cleanGraph(self.graph_drawing)\n #if len(self.graph_drawing)>1:\n # self.function_interpolation=self.polynomialInterpolation2D(self.graph_drawing,1)\n # self.graph_interpolation=self.sample(self.function_interpolation,len(self.graph_drawing))\n elif self.mode==1: #construction\n self.step+=1\n self.time=self.step/self.max_step\n if self.step>self.max_step:\n self.mode=2\n #self.graph_construction=self.discreteComplexComposeGraph(self.coefficients,self.time) #complex now\n self.graph_construction=self.numpyComposeConstructionGraph(self.coefficients,t=self.time)\n self.vectors=self.getVectors([(0,0)]+self.graph_construction)\n self.graph_display.append(self.graph_construction[-1])\n\n elif self.mode==2:\n self.draw()","def __set_transform_matrices(self):\n self.tf_matrices_list = []\n\n transform_matrix = eye(4) # creates a unit matrix via passing argument.\n for i in range(self.joint_count):\n transform_matrix = transform_matrix * self.__create_tf_matrix(self.alpha[i], self.a[i], self.d[i], self.q[i]).subs(self.dh_params)\n self.tf_matrices_list.append(transform_matrix)","def assemble_matrices(self):\n \n #Pointer reassignment for convenience\n N = self.ngrids\n\n #Begin with a linked-list data structure for the transmissibilities,\n #and one-dimenstional arrays for the diagonal of B and the flux vector\n T = lil_matrix((N, N), dtype=np.double)\n B = np.zeros(N, dtype=np.double)\n Q = np.zeros(N, dtype=np.double)\n\n #Read in boundary condition types and values\n bcs = self.input_data['boundary conditions']\n bc_type_1 = bcs['left']['type'].lower()\n bc_type_2 = bcs['right']['type'].lower()\n bc_value_1 = bcs['left']['value']\n bc_value_2 = bcs['right']['value']\n \n #Loop over all grid cells\n for i in range(N):\n\n #Apply left BC\n if i == 0:\n T[i, i+1] = -self.compute_transmissibility(i, i + 1)\n\n if bc_type_1 == 'neumann':\n T[i, i] = T[i,i] - T[i, i+1]\n elif bc_type_1 == 'dirichlet':\n #Computes the transmissibility of the ith block\n T0 = self.compute_transmissibility(i, i)\n T[i, i] = T[i,i] - T[i, i+1] + 2.0 * T0\n Q[i] = 2.0 * T0 * bc_value_1\n else:\n pass #TODO: Add error checking here if no bc is specified\n\n #Apply right BC\n elif i == (N - 1):\n T[i, i-1] = -self.compute_transmissibility(i, i - 1)\n\n if bc_type_2 == 'neumann':\n T[i, i] = T[i,i] - T[i, i-1]\n elif bc_type_2 == 'dirichlet':\n #Computes the transmissibility of the ith block\n T0 = self.compute_transmissibility(i, i)\n T[i, i] = T[i, i] - T[i, i-1] + 2.0 * T0\n Q[i] = 2.0 * T0 * bc_value_2\n else:\n pass #TODO:Add error checking here if no bc is specified\n\n #If there is no boundary condition compute interblock transmissibilties\n else:\n T[i, i-1] = -self.compute_transmissibility(i, i-1)\n T[i, i+1] = -self.compute_transmissibility(i, i+1)\n T[i, i] = (self.compute_transmissibility(i, i-1) +\n self.compute_transmissibility(i, i+1))\n\n #Compute accumulations\n B[i] = self.compute_accumulation(i)\n\n #If constant-rate wells are present, add them to the flux vector\n if self.rate_well_grids is not None:\n Q[self.rate_well_grids] += self.rate_well_values\n\n \n #Return sparse data-structures\n return (T.tocsr(), \n csr_matrix((B, (np.arange(N), np.arange(N))), shape=(N,N)), \n Q)","def run(self):\n super().run()\n # more verbose creation date for clarity\n creation_date = f'20{self.creation_date}'\n make_e3sm_to_cmip_maps(self.config, self.logger, self.mesh_short_name,\n creation_date, self.ntasks)","def build(self, input_shape):\n\n # get shape of input matrix x\n self.num_of_vertices = input_shape[1]\n self.num_of_features = input_shape[2]\n self.num_of_timesteps = input_shape[3]\n #self.W_1.shape = (num_of_timesteps,)\n #self.W_2.shape = (num_of_features, num_of_timesteps)\n #self.W_3.shape = (num_of_features,)\n #self.b_s.shape = (1, num_of_vertices, num_of_vertices)\n #self.V_s.shape = (num_of_vertices, num_of_vertices)\n\n self.w1 = self.add_weight(name='w1', shape=(self.num_of_timesteps, ),\n initializer='glorot_normal', trainable=True)\n self.w2 = self.add_weight(name='w2', shape=(self.num_of_features, self.num_of_timesteps),\n initializer='glorot_normal', trainable=True)\n self.w3 = self.add_weight(name='w3', shape=(self.num_of_features,),\n initializer='glorot_normal', trainable=True)\n self.b = self.add_weight(name='b', shape=(1, self.num_of_vertices, self.num_of_vertices),\n initializer='zeros', trainable=True)\n self.v = self.add_weight(name='v', shape=(self.num_of_vertices, self.num_of_vertices),\n initializer='glorot_normal', trainable=True)\n\n super(Spatial_Attention_layer, self).build(input_shape)","def generate(self, n_enemies, n_blocks):\n self.create_map()\n self.create_floor()\n self.player = self.create_player_at(0, 0)\n self.create_dummy_obj_at(0, 1)\n self.create_dummy_obj_at(1, 0)\n self.create_soft_block_at(0, 2)\n self.create_soft_block_at(2, 0)\n self.create_hard_blocks() \n self.create_enemies(n_enemies)\n self.create_soft_blocks(n_blocks) \n self.clear_dummy_obj()","def model(inputs):\n outputs = {}\n\n # First, build the encoder\n encoder_fn = _get_network(params.encoder_name)\n with tf.variable_scope('encoder', reuse=reuse):\n # Produces id/pose units\n enc_outputs = encoder_fn(inputs['images_1'], params, is_training)\n outputs['ids_1'] = enc_outputs['ids']\n\n # Second, build the decoder and projector\n decoder_fn = _get_network(params.decoder_name)\n with tf.variable_scope('decoder', reuse=reuse):\n outputs['voxels_1'] = decoder_fn(outputs['ids_1'], params, is_training)\n if run_projection:\n projector_fn = _get_network(params.projector_name)\n with tf.variable_scope('projector', reuse=reuse):\n outputs['projs_1'] = projector_fn(\n outputs['voxels_1'], inputs['matrix_1'], params, is_training)\n # Infer the ground-truth mask\n with tf.variable_scope('oracle', reuse=reuse):\n outputs['masks_1'] = projector_fn(inputs['voxels'], inputs['matrix_1'],\n params, False)\n\n # Third, build the entire graph (bundled strategy described in PTN paper)\n for k in range(1, params.step_size):\n with tf.variable_scope('projector', reuse=True):\n outputs['projs_%d' % (k + 1)] = projector_fn(\n outputs['voxels_1'], inputs['matrix_%d' %\n (k + 1)], params, is_training)\n with tf.variable_scope('oracle', reuse=True):\n outputs['masks_%d' % (k + 1)] = projector_fn(\n inputs['voxels'], inputs['matrix_%d' % (k + 1)], params, False)\n\n return outputs","def synthetic_gen(self):\r\n logging.debug('generating synthetic map...')\r\n data = self.realData\r\n unit = Params.unitGrid\r\n x_min = np.floor(Params.LOW[0] / unit) * unit\r\n x_max = np.ceil(Params.HIGH[0] / unit) * unit\r\n y_min = np.floor(Params.LOW[1] / unit) * unit\r\n y_max = np.ceil(Params.HIGH[1] / unit) * unit\r\n\r\n x_CELL = int(np.rint((x_max - x_min) / unit))\r\n y_CELL = int(np.rint((y_max - y_min) / unit))\r\n\r\n self.root.n_box = np.array([[x_min, y_min], [x_max, y_max]])\r\n\r\n self.mapp = np.zeros((x_CELL, y_CELL)) - 1 # ## initialize every cell with -1\r\n for i in range(Params.NDATA): # ## populate the map\r\n point = data[:, i]\r\n cell_x = int(np.floor((point[0] - x_min) / unit))\r\n cell_y = int(np.floor((point[1] - y_min) / unit))\r\n if self.mapp[cell_x, cell_y] != -1:\r\n self.mapp[cell_x, cell_y] += 1\r\n else:\r\n self.mapp[cell_x, cell_y] = 1\r\n\r\n for i in range(x_CELL): # ## perturb the counts\r\n for j in range(y_CELL):\r\n if self.mapp[i, j] != -1:\r\n self.mapp[i, j] += np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\r\n else:\r\n self.mapp[i, j] = np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\r\n # if noisy count is negative, ignore the noise and generate no points\r\n if self.mapp[i, j] < 0:\r\n self.mapp[i, j] = 0","def build(self, input_shape):\n\n # get shape of input matrix x\n num_of_vertices = input_shape[1]\n num_of_features = input_shape[2]\n num_of_timesteps = input_shape[3]\n #self.U_1.shape = (num_of_vertices,)\n #self.U_2.shape = (num_of_features, num_of_vertices)\n #self.U_3.shape = (num_of_features,)\n #self.b_e.shape = (1, num_of_timesteps, num_of_timesteps)\n #self.V_e.shape = (num_of_timesteps, num_of_timesteps)\n\n self.u1 = self.add_weight(name='u1', shape=(num_of_vertices, ),\n initializer='glorot_normal', trainable=True)\n self.u2 = self.add_weight(name='u2', shape=(num_of_features, num_of_vertices),\n initializer='glorot_normal', trainable=True)\n self.u3 = self.add_weight(name='u3', shape=(num_of_features,),\n initializer='glorot_normal', trainable=True)\n self.b = self.add_weight(name='b', shape=(1, num_of_timesteps, num_of_timesteps),\n initializer='zeros', trainable=True)\n self.v = self.add_weight(name='v', shape=(num_of_timesteps, num_of_timesteps),\n initializer='glorot_normal', trainable=True)\n\n super(Temporal_Attention_layer, self).build(input_shape)","def _generate_weighted_matrices(self):\n self.degree_weighted_matrices = dict()\n mes = []\n args = []\n for metaedge, matrix in self.adj_matrices.items():\n mes.append(metaedge)\n args.append({'matrix': matrix, 'w': self.w, 'degree_fwd': self.out_degree[metaedge],\n 'degree_rev': self.in_degree[metaedge]})\n res = parallel_process(array=args, function=mt.weight_by_degree, use_kwargs=True, n_jobs=self.n_jobs,\n front_num=0)\n for metaedge, matrix in zip(mes, res):\n self.degree_weighted_matrices[metaedge] = matrix"],"string":"[\n \"def assembleMatrices(self):\\n # All nodes informations\\n self.aircraftNodesPoints = []\\n self.aircraftMassPoints = []\\n self.aircraftMassDistances = []\\n self.aircraftSegmentsLengths = []\\n self.aircraftNodesNames = []\\n self.aircraftInitNodesAreas = []\\n self.aircraftNodesA = []\\n self.aircraftNodesIy = []\\n self.aircraftNodesIz = []\\n self.aircraftNodesJ = []\\n # More general information\\n self.aircraftConnectedNodes = []\\n self.aircraftNonRotatingNodes = []\\n\\n self.computeProportionFuselage()\\n self.computeProportionWings()\\n\\n # adds fulseage infos to matrices if there is one\\n if self.nFuselage > 0:\\n self.aircraftNodesPoints.append(self.fs_m_points[0])\\n # Assumption is made that for a fuselage section, its cog is\\n # aligned with the section center.\\n self.aircraftMassPoints.append(self.fs_m_points[0])\\n self.aircraftMassDistances.append(np.zeros((len(self.fs_m_points[0]),3)))\\n self.aircraftSegmentsLengths.append(self.fs_m_distanceBetweenPoints[0])\\n self.aircraftNodesNames.append(self.fs_m_pointsName[0])\\n self.aircraftInitNodesAreas.append(self.fs_m_pointsInitArea[0])\\n self.aircraftNodesA.append(self.fs_m_pointsA[0])\\n self.aircraftNodesIy.append(self.fs_m_pointsIy[0])\\n self.aircraftNodesIz.append(self.fs_m_pointsIz[0])\\n self.aircraftNodesJ.append(self.fs_m_pointsJ[0])\\n logger.debug('\\\\n')\\n for i in range(self.nWings):\\n self.aircraftNodesPoints.append(self.ws_me_points[i])\\n self.aircraftMassPoints.append(self.ws_ma_points[i])\\n self.aircraftMassDistances.append(self.ws_ma_distance[i])\\n self.aircraftSegmentsLengths.append(self.ws_me_distances[i])\\n # logger.debug(i)\\n # logger.debug(self.ws_me_distances)\\n # logger.debug(self.aircraftSegmentsLengths)\\n self.aircraftNodesNames.append(self.ws_me_pointsName[i])\\n self.aircraftInitNodesAreas.append(self.ws_me_pointsInitArea[i])\\n self.aircraftNodesA.append(self.ws_me_pointsA[i])\\n self.aircraftNodesIy.append(self.ws_me_pointsIy[i])\\n self.aircraftNodesIz.append(self.ws_me_pointsIz[i])\\n self.aircraftNodesJ.append(self.ws_me_pointsJ[i])\\n self.computeMass()\",\n \"def generate_image_matrices():\\r\\n for i in range(int(number_of_matrices.get())):\\r\\n clear_space()\\r\\n populate_image_lists()\\r\\n randomly_select_images()\\r\\n get_image_data()\\r\\n grid_frame = Image.new(\\\"RGB\\\", (matrix_x_pix, matrix_y_pix), \\\"white\\\")\\r\\n image_index = 0\\r\\n for j in range(matrix_x):\\r\\n for k in range(matrix_y):\\r\\n img = Image.open(images_total[image_index])\\r\\n grid_frame.paste(img, (padding + (j * (padding + image_x)),\\r\\n padding + (k * (padding + image_y))))\\r\\n image_index += 1\\r\\n\\r\\n save_path = (os.path.join(dir_path, \\\"outputs\\\\\\\\\\\") +\\r\\n number_of_images_a.get() + \\\"a\\\" +\\r\\n number_of_images_b.get() + \\\"b_img\\\" + str(i) + \\\".png\\\")\\r\\n grid_frame.save(save_path, \\\"PNG\\\")\",\n \"def make_all(self):\\n # General matrices #\\n self.tsv_seq_to_concepts()\\n self.tsv_seq_to_names()\\n self.list_sequence_concept()\\n # Only in the with 'samples' case #\\n if self.a.abundances: self.tsv_samples_to_names()\\n if self.a.abundances: self.biom_output()\\n # Graphical outputs #\\n self.per_seq_dot_files()\\n if self.a.abundances: self.per_sample_dot_files()\",\n \"def _derive_transformation_matrices(self):\\n\\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\\n if self._primaries is not None and self._whitepoint is not None:\\n npm = normalised_primary_matrix(self._primaries,\\n self._whitepoint)\\n\\n self._derived_RGB_to_XYZ_matrix = npm\\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)\",\n \"def build(self):\\n self.build_inputs()\\n self.build_word_embeddings()\\n self.build_encoder()\\n self.build_fc()\\n self.build_loss()\\n self.build_global_step()\",\n \"def build_matrix(self):\\n self.lb_make = LabelEncoder()\\n self.lb_make.fit(self.Y_train)\\n tokenizer = Tokenizer(num_words=2000)\\n x_array_train = numpy.asarray(self.train['text'])\\n x_array_test = numpy.asarray(self.test['text'])\\n tokenizer.fit_on_texts(x_array_train)\\n x_train_matrix = tokenizer.texts_to_matrix(x_array_train, mode='count')\\n x_test_matrix = tokenizer.texts_to_matrix(x_array_test, mode='count')\\n y_train_numbers = self.lb_make.transform(self.Y_train)\\n y_test_numbers = self.lb_make.transform(self.Y_test)\\n y_train_matrix = keras.utils.to_categorical(y_train_numbers, 3)\\n y_test_matrix = keras.utils.to_categorical(y_test_numbers, 3)\\n self.tokenizer = tokenizer\\n return x_train_matrix, x_test_matrix, y_train_matrix, y_test_matrix\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def build_graph(self):\\n self.__create_placeholders()\\n self.__create_encoder()\\n self.__create_latent()\\n self.__create_decoder()\\n self.__create_loss()\\n self.__create_generate()\\n self.__create_reconstruct()\\n self.__create_optimizer()\\n self.__create_summary()\",\n \"def build_graph(self):\\n\\t\\tself._create_placeholders()\\n\\t\\tself._create_embedding()\\n\\t\\tself._create_recurrent_layers()\\n\\t\\tself._create_de_embedding()\\n\\t\\tself._create_loss()\\n\\t\\tself._create_optimizer()\\n\\t\\tself._create_summaries()\",\n \"def create_matrices(self):\\n debut = time.process_time()\\n\\n x = np.arange(0, self.axe_X)\\n y = np.arange(0, self.axe_Y)\\n xv, yv = np.meshgrid(x, y)\\n\\n print(\\\"\\\\nmatrix creation estimation time: %.1fs\\\" % (1e-6*self.axe_X*self.axe_Y))\\n\\n img_matrix_x, img_matrix_y = self.find_position(xv, yv)\\n\\n fin = time.process_time()\\n print(\\\"matrix created in time: %.1f s\\\" % (fin-debut))\\n return img_matrix_x, img_matrix_y\",\n \"def _generate_network_initialization(self, graph, memory_manager):\\n\\n # TODO: To be changed if we want to support multiple outputs\\n output_buffer_name = graph.outputs[0].name\\n\\n ops_to_ignore = ['Reshape', 'Mul']\\n\\n buffers_allocated = []\\n\\n buffer_declaration = \\\"\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **kernels;\\\\n\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **biases;\\\\n\\\"\\n\\n constructor_code = \\\"\\\"\\n #constructor_code += \\\"Network::Network() {\\\\n\\\\n\\\"\\n\\n num_layers = 0\\n num_kernels = 0\\n num_biases = 0\\n\\n for node in graph.nodes:\\n \\\"\\\"\\\"Do not count the reshape layers as the input tensor will only define the dimensions\\\"\\\"\\\"\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n num_layers += 1\\n for num, input in enumerate(node.input_tensors):\\n if input in buffers_allocated:\\n continue\\n else:\\n tensor = node.input_tensors[input]\\n buffers_allocated.append(input)\\n if len(tensor.shape) == 1:\\n num_biases += 1\\n else:\\n num_kernels += 1\\n\\n \\\"\\\"\\\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\\\"\\\"\\\"\\n constructor_code += \\\" kernels = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\".format(num_kernels)\\n constructor_code += \\\" biases = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\\n\\\".format(num_biases)\\n\\n pos = -1\\n pos_kernel = -1\\n pos_bias = -1\\n\\n buffers_allocated.clear()\\n\\n \\\"\\\"\\\"Iterate over all nodes in the graph and generate the corresponding allocation code.\\\"\\\"\\\"\\n for node_id, node in enumerate(graph.nodes):\\n\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n pos += 1\\n\\n buffer_declaration += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n constructor_code += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n\\n # Allocate memory for kernels and biases\\n buffer_declaration += \\\" // Inputs\\\\n\\\"\\n constructor_code += \\\" // Inputs\\\\n\\\"\\n for num, input in enumerate(node.input_tensors):\\n\\n if node.op_type in ops_to_ignore:\\n continue\\n\\n if input in buffers_allocated:\\n continue\\n else:\\n buffers_allocated.append(input)\\n\\n tensor = node.input_tensors[input]\\n if len(tensor.shape) == 1:\\n pos_bias += 1\\n else:\\n pos_kernel += 1\\n\\n buffer = memory_manager.get_buffer(graph, input)\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"KernelAllocation\\\")\\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\" // Outputs\\\\n\\\"\\n constructor_code += \\\" // Outputs\\\\n\\\"\\n for num, output in enumerate(node.outputs):\\n\\n buffer = memory_manager.get_buffer(graph, output)\\n\\n if output == output_buffer_name:\\n buffer_declaration += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n constructor_code += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n continue\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"OutputAllocation\\\")\\n impl = functionality[0].create(buffer)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\"\\\\n\\\\n\\\"\\n constructor_code += \\\"\\\\n\\\\n\\\"\\n\\n #constructor_code += \\\"}\\\\n\\\"\\n\\n self.buffer_declaration = buffer_declaration\\n self.constructor_code = constructor_code\",\n \"def create_training_matrices(experiment, sample_times):\\n # Labels:\\n location_labels = read_location_labels(experiment)\\n locations = get_location_of_persons_at_samples(location_labels, sample_times, experiment)\\n\\n p1_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P1\\\")\\n p2_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P2\\\")\\n p3_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P3\\\")\\n p4_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P4\\\")\\n\\n print(p1_scene_features.loc[0]['predictions'].shape[0])\\n print(len(p1_scene_features['predictions'][0]))\\n data = {\\n \\\"P1\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P2\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P3\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P4\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0]))\\n }\\n\\n for index, loc_label in enumerate(locations):\\n t = loc_label[0]\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P1_eyetracker\\\")\\n p1 = np.mean(p1_scene_features[p1_scene_features['timestamp'].between(t_et - sample_step/2, t_et + sample_step/2)]['predictions'].as_matrix(), axis=0)\\n\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P2_eyetracker\\\")\\n p2 = np.mean(\\n p2_scene_features[p2_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P3_eyetracker\\\")\\n p3 = np.mean(\\n p3_scene_features[p3_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P4_eyetracker\\\")\\n p4 = np.mean(\\n p4_scene_features[p4_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n data[\\\"P1\\\"][index, 0] = t\\n data[\\\"P1\\\"][index, 1:-1] = p1\\n data[\\\"P1\\\"][index, -1] = loc_label[1]\\n\\n data[\\\"P2\\\"][index, 0] = t\\n data[\\\"P2\\\"][index, 1:-1] = p2\\n data[\\\"P2\\\"][index, -1] = loc_label[2]\\n\\n data[\\\"P3\\\"][index, 0] = t\\n data[\\\"P3\\\"][index, 1:-1] = p3\\n data[\\\"P3\\\"][index, -1] = loc_label[3]\\n\\n data[\\\"P4\\\"][index, 0] = t\\n data[\\\"P4\\\"][index, 1:-1] = p4\\n data[\\\"P4\\\"][index, -1] = loc_label[4]\\n\\n return data\",\n \"def initParams(self):\\n sizes = [self.inputDim]+self.layerSizes+[self.outputDim]\\n scales = [np.sqrt(6)/np.sqrt(n+m) for n,m in zip(sizes[:-1],sizes[1:])]\\n self.stack = [[np.random.rand(m,n)*2*s-s,np.zeros((m,1))] \\\\\\n for n,m,s in zip(sizes[:-1],sizes[1:],scales)]\\n self.hActs_M = [cm.empty((s,self.maxBatch)) for s in sizes]\\n\\n if self.train:\\n # Now assuming that all layers are the same size\\n self.grad = [[cm.empty(w.shape),cm.empty(b.shape)] for w,b in self.stack]\\n self.deltasC_M = cm.empty((self.outputDim,self.maxBatch))\\n self.deltasOut_M = cm.empty((sizes[1],self.maxBatch)) \\n self.deltasIn_M = cm.empty((sizes[1],self.maxBatch)) \\n self.tmpGrad_M = cm.empty((self.layerSize,self.maxBatch))\\n \\n # Allocate memory once here and reuse\\n # Store probs\\n self.probs_M = cm.empty((self.outputDim,self.maxBatch))\\n # Store col max\\n self.rowVec_M = cm.empty((1,self.maxBatch))\\n \\n self.stack = [[cm.CUDAMatrix(w),cm.CUDAMatrix(b)]\\n for w,b in self.stack]\\n\\n if self.temporalLayer > 0:\\n # dummy bias used for temporal layer\\n dummy = cm.empty((1,1))\\n dummy.assign(0.0)\\n\\n scale = np.sqrt(6)/np.sqrt(self.layerSize*2)\\n wtf = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\\n self.layerSize)-scale)\\n wtb = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\\n self.layerSize)-scale)\\n self.stack.append([wtf,dummy])\\n self.stack.append([wtb,dummy])\\n\\n # forward and backward activations for temporal layer\\n self.hActsFor_M = cm.empty((self.layerSize,self.maxBatch))\\n self.hActsBack_M = cm.empty((self.layerSize,self.maxBatch))\\n\\n if self.train:\\n dwtf = cm.empty(wtf.shape)\\n self.grad.append([dwtf,dummy])\\n dwtb = cm.empty(wtb.shape)\\n self.grad.append([dwtb,dummy])\\n\\n self.tmpGradBack_M = cm.empty((self.layerSize,self.maxBatch))\\n self.deltasFor_M = cm.empty((self.layerSize,self.maxBatch))\\n self.deltasBack_M = cm.empty((self.layerSize,self.maxBatch))\",\n \"def build(self):\\n self.build_inputs()\\n self.build_image_embeddings()\\n self.build_seq_embeddings()\\n self.build_encoder()\\n self.build_prediction_model()\\n self.setup_encoder_initializer()\\n self.setup_global_step()\\n self.list_trainable_variables()\",\n \"def compile(self):\\n for layer in self.layers:\\n layer._Dense__load()\",\n \"def build(self):\\n self.build_inputs()\\n self.image_embeddings = self.build_image_embeddings(self.images)\\n self.seq_embeddings = self.build_seq_embeddings(self.input_seqs)\\n self.build_model()\\n self.setup_inception_initializer()\\n self.setup_global_step()\",\n \"def newMatrix(self):\\n self.matrix = makeMatrix()\\n for row in range(self.matrix.getHeight()):\\n for column in range(self.matrix.getWidth()):\\n self.canvasGrid[row][column].draw(self.matrix[row][column])\",\n \"def generate_mxp_graph(model_name, activations, stats, first_node_name, last_node_name, io_info,\\n input_type, ignore_strides=False, inline_depthwise=False, verbose=False):\\n network = {}\\n network['layers'] = []\\n network['test_input'] = None\\n network['test_output'] = None\\n network['scale'] = 1.0\\n\\n model = onnx.load(model_name)\\n nodes = model.graph.node\\n inits = model.graph.initializer\\n\\n idx = get_node_index(nodes, first_node_name)\\n if idx == None:\\n if verbose:\\n print('{} does not exist\\\\nopen {} in Netron + check spelling'.format(first_node_name, mname))\\n assert(idx != None)\\n\\n last_idx = get_node_index(nodes, last_node_name)\\n if last_idx == None:\\n if verbose:\\n print('{} does not exist\\\\nopen {} in Netron + check spelling'.format(last_node_name, mname))\\n assert(last_idx != None)\\n\\n while True:\\n node = nodes[idx]\\n if verbose:\\n print(node.name, node.op_type)\\n src_node = get_node_source(nodes, node.input[0])\\n if src_node == None:\\n input_id = node.input[0]\\n else:\\n input_id = src_node.output[0]\\n output_id = node.output[0]\\n\\n\\n if len(network['layers']) == 0:\\n previous = None\\n else:\\n previous = network['layers'][-1]\\n for layer in network['layers']:\\n if layer['output_id'] == input_id:\\n previous = layer\\n\\n input_shapes, output_shapes = get_shapes(activations, stats, node)\\n assert len(output_shapes) == 1, \\\"Multi-output nodes not supported\\\"\\n output_shape = output_shapes[0]\\n if node.op_type == \\\"Conv\\\":\\n c, m, n = input_shapes[0]\\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\\n assert(get_attr(node, 'pads') == None or not any(get_attr(node, 'pads')))\\n\\n group = get_attr(node, 'group')\\n strides = np.asarray(get_attr(node, 'strides')).tolist()\\n dilations = np.asarray(get_attr(node, 'dilations')).tolist()\\n if not group:\\n group = 1\\n if not strides:\\n strides = [1, 1]\\n if not dilations:\\n dilations = [1, 1]\\n\\n use_strided = 0\\n assert(strides == [1, 1] or strides == [2, 2] or strides == [4, 4])\\n\\n if DO_STRIDES and not ignore_strides:\\n if (strides[0] > 1 or strides[1] > 1) and group == 1: # TODO handle depthwise as well\\n assert(previous['output_size'] == int(np.prod(input_shapes[0])))\\n use_strided = 1\\n previous['output_strides'] = strides\\n if verbose:\\n print('adding output strides to previous node')\\n\\n m = m + (m % strides[0])\\n n = n + (n % strides[1])\\n if int(np.prod(input_shapes[0])) != int(c*m*n):\\n if verbose:\\n print('adjusting size for strided maps')\\n previous['output_size'] = int(c*4*m//strides[0]*n//strides[1])\\n previous['output_shape'] = (c*4,m//strides[0],n//strides[1])\\n\\n w = get_tensor(inits, node.input[1])\\n kernels, channels, _, _ = w.shape\\n if len(node.input) == 3:\\n b = get_tensor(inits, node.input[2])\\n\\n conv_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(c*m*n),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels * group,\\n 'kernels': kernels,\\n 'kernel_shape': kernel_shape,\\n 'dilations': dilations,\\n 'strides': strides,\\n 'group': group,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n 'use_cvi': 0,\\n 'use_depthwise': 0,\\n 'use_strided': use_strided,\\n \\\"biases\\\": [],\\n \\\"weights\\\": [],\\n \\\"sublayers\\\": [],\\n }\\n\\n w = w.flatten().tolist()\\n conv_layer['weights'] = base64.b64encode(struct.pack(\\\"f\\\"*len(w), *w)).decode()\\n\\n if len(node.input) == 3:\\n b = b.flatten().tolist()\\n else:\\n b = [0 for _ in range(kernels)]\\n conv_layer['biases'] = base64.b64encode(struct.pack(\\\"f\\\"*len(b), *b)).decode()\\n\\n network['layers'].append(conv_layer)\\n\\n elif node.op_type == \\\"Gemm\\\":\\n w = get_tensor(inits, node.input[1])\\n output_size, input_size = w.shape\\n\\n if len(node.input) == 3:\\n b = get_tensor(inits, node.input[2])\\n\\n gemm_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(np.prod(input_shapes[0])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape': output_shape,\\n 'gemm_input_size': input_size,\\n 'gemm_output_size': output_size,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"biases\\\": [],\\n \\\"weights\\\": [],\\n \\\"sublayers\\\": [],\\n }\\n\\n w = w.flatten().tolist()\\n gemm_layer['weights'] = base64.b64encode(struct.pack(\\\"f\\\"*len(w), *w)).decode()\\n\\n if len(node.input) == 3:\\n b = b.flatten().tolist()\\n else:\\n b = [0 for _ in range(output_size)]\\n gemm_layer['biases'] = base64.b64encode(struct.pack(\\\"f\\\"*len(b), *b)).decode()\\n network['layers'].append(gemm_layer)\\n\\n elif node.op_type in multipath_nodes:\\n node_inputs = get_previous_nodes(nodes, node)\\n shapes = input_shapes\\n\\n if node.op_type == \\\"Sum\\\":\\n assert(all([x == shapes[0] for x in shapes[1:]]))\\n elif node.op_type == \\\"Concat\\\":\\n assert(all([x[1:] == shapes[0][1:] for x in shapes[1:]]))\\n\\n buf = node_inputs[0].name\\n if node.op_type == \\\"Concat\\\":\\n buf = output_id\\n\\n buffer_offset = 0\\n for n, node_input in enumerate(node_inputs):\\n noutput = node_input.output[0]\\n for l, layer in enumerate(network['layers']):\\n if layer['output_id'] == noutput: # if layer pointing to this node\\n network['layers'][l]['output_id'] = buf # rename layer's output\\n network['layers'][l]['buffer_offset'] = buffer_offset # and offset appropriately\\n if layer['input_id'] == noutput:\\n network['layers'][l]['input_id'] = buf #TODO\\n\\n buffer_offset += int(np.prod(input_shapes[n]))\\n\\n if node.op_type == \\\"Sum\\\":\\n channels, m, n = shape3d(output_shape)\\n sum_layer = {\\n 'op_type': \\\"Sum\\\",\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': node_inputs[0].name,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n 'num_inputs': len(node.input),\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(sum_layer)\\n\\n elif node.op_type == \\\"Identity\\\":\\n shapes = input_shapes\\n\\n channels, m, n = shape3d(output_shape)\\n identity_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(identity_layer)\\n\\n elif node.op_type == \\\"LRN\\\":\\n shapes = input_shapes\\n channels, m, n = shape3d(output_shape)\\n lrn_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'alpha': get_attr(node, 'alpha'),\\n 'beta': get_attr(node, 'beta'),\\n 'bias': get_attr(node, 'bias'),\\n 'size': get_attr(node, 'size'),\\n 'scale': 1.0,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(lrn_layer)\\n\\n elif node.op_type == \\\"Scale\\\":\\n scale_sublayer = {\\n 'op_type': 'Scale',\\n 'name': node.name,\\n \\\"use_replay\\\": 1,\\n 'scale': get_attr(node, 'scale'),\\n }\\n previous['sublayers'].append(scale_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type in [\\\"GlobalAveragePool\\\", \\\"GlobalMaxPool\\\"]:\\n assert(previous['n'] == previous['m'])\\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\\n strides = np.asarray(get_attr(node, 'strides')).tolist()\\n pads = pads6(node)\\n pool_sublayer = {\\n 'op_type': node.op_type.replace('Global', ''),\\n 'name': node.name,\\n 'use_replay': 0,\\n 'kernel_shape': [previous['m'], previous['n']],\\n 'strides': [previous['m'], previous['n']],\\n 'pads': pads,\\n }\\n previous['sublayers'].append(pool_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n previous['output_shape'] = (output_shape)\\n\\n elif node.op_type in [\\\"MaxPool\\\", \\\"AveragePool\\\"]:\\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\\n\\n if node.op_type == \\\"AveragePool\\\": #TODO quick fix for tf average pool quirk\\n if kernel_shape[0] * kernel_shape[1] == previous['m'] * previous['n']:\\n kernel_shape = [previous['m'], previous['n']]\\n strides = np.asarray(get_attr(node, 'strides')).tolist()\\n if strides is None:\\n strides = [ 1 for _ in kernel_shape]\\n pads = pads6(node)\\n pool_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'kernel_shape': kernel_shape,\\n 'strides': strides,\\n 'pads': pads,\\n }\\n previous['sublayers'].append(pool_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n previous['output_shape'] = (output_shape)\\n elif node.op_type == \\\"PRelu\\\":\\n slope = get_tensor(inits, node.input[1])\\n slope = slope.flatten().tolist()\\n prelu_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'slope': slope,\\n }\\n previous['sublayers'].append(prelu_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"LeakyRelu\\\":\\n alpha = get_attr(node, 'alpha')\\n if alpha is None:\\n alpha = .01\\n leaky_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'alpha': alpha\\n }\\n previous['sublayers'].append(leaky_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"Relu\\\":\\n relu_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n }\\n previous['sublayers'].append(relu_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"Clip\\\":\\n clip_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'min': float(get_tensor(inits,node.input[1])),\\n 'max': float(get_tensor(inits,node.input[2])),\\n }\\n previous['sublayers'].append(clip_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"Pad\\\":\\n pads = pads6(get_tensor(inits,node.input[1]).tolist())\\n value = int(get_tensor(inits,node.input[2]))\\n if value < -1:\\n value = -1\\n if value > 1:\\n value = 1\\n pad_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'value': value,\\n 'pads': pads,\\n }\\n previous['sublayers'].append(pad_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n previous['output_shape'] = (output_shape)\\n elif node.op_type in [\\\"Add\\\", \\\"Mul\\\", \\\"Sub\\\", \\\"Div\\\"]:\\n\\n skip = False\\n if node.op_type == \\\"Mul\\\":\\n next_nodes = get_node_inputs(nodes, node.output[0])\\n if node.name == nodes[-1].name:\\n if verbose:\\n print('removing final scale node')\\n skip = True\\n\\n elif previous['op_type'] in [\\\"LRN\\\"]:\\n if verbose:\\n print('skipping mul after lrn')\\n array = get_tensor(inits, node.input[1])\\n if array is None:\\n array = get_tensor(inits, node.input[0])\\n previous['scale'] = float(array[0])\\n print('skipping mul after lrn', previous['scale'], previous['input_id'], previous['output_id'])\\n\\n skip = True\\n\\n elif next_nodes[0].op_type in [\\\"Softmax\\\"]:\\n if verbose:\\n print('skipping mul before softmax')\\n skip = True\\n\\n array = get_tensor(inits, node.input[1])\\n if array is None:\\n array = get_tensor(inits, node.input[0])\\n c = activations[node.input[1]].shape[1]\\n else:\\n c = input_shapes[0][0]\\n\\n if node.op_type == \\\"Add\\\": # TODO for scalar Add\\n dims = len(np.squeeze(array).shape)\\n if dims == 0:\\n array = np.ones((c, 1)) * array\\n\\n dims = len(np.squeeze(array).shape)\\n if c == 1 and dims == 0:\\n dims = 1\\n\\n array = array.flatten().tolist()\\n # force_broadcast_2 = False\\n # if force_broadcast_2:\\n # # if c != 1 and dims == 0:\\n # if c != 1 and dims == 0 and node.op_type != \\\"Mul\\\": # TODO forcing to broadcast 2 not broadcast 3\\n # dims = 1\\n # array = [array[0] for _ in range(c)]\\n\\n if not skip:\\n arithmetic_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'dims': dims,\\n 'array': array,\\n }\\n previous['sublayers'].append(arithmetic_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type in [\\\"Abs\\\", \\\"Max\\\", \\\"Mean\\\", \\\"Min\\\", \\\"Neg\\\", \\\"Not\\\"]:\\n unary_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n }\\n previous['sublayers'].append(unary_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n\\n elif node.op_type == \\\"Reshape\\\":\\n dims = get_tensor(inits, node.input[1])\\n\\n if len(dims) == 4 and dims[-1] == 2:\\n idx += 6\\n node = nodes[idx]\\n output_id = node.output[0]\\n _, output_shapes = get_shapes(activations, stats, node)\\n output_shape = output_shapes[0]\\n channels, m, n = shape3d(output_shape)\\n reorg_layer = {\\n 'op_type': \\\"Reorg\\\",\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape': output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n \\\"stride\\\": int(dims[-1]),\\n }\\n network['layers'].append(reorg_layer)\\n else:\\n previous['output_id'] = output_id\\n\\n elif node.op_type in [\\\"Flatten\\\",'Cast']:\\n previous['output_id'] = output_id\\n elif node.op_type == \\\"Resize\\\":\\n scales = get_tensor(inits, node.input[2])\\n assert(scales[0] == 1 and scales[1] == 1)\\n scale = float(scales[2])\\n mode = get_attr(node, 'mode').decode()\\n assert(mode == 'nearest' or mode == 'linear')\\n shapes = input_shapes[:1]\\n channels, m, n = shape3d(output_shape)\\n in_size= [d for d in one_elem(input_shapes)[1:]]\\n replay = 0 if in_size == [1,1] else 1\\n resize_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': replay,\\n 'input_size': int(np.prod(one_elem(input_shapes))),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'mode' :mode,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n 'scale': [float(scales[2]),float(scales[3])],\\n }\\n network['layers'].append(resize_layer)\\n elif node.op_type == \\\"ArgMax\\\":\\n input_shape = one_elem(input_shapes)\\n channels, m, n = shape3d(input_shape)\\n argmax_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n 'scale': [float(scales[2]),float(scales[3])],\\n }\\n network['layers'].append(argmax_layer)\\n\\n elif node.op_type == \\\"Softmax\\\":\\n prev = get_previous_nodes(nodes, node)[0]\\n if prev.op_type == \\\"Mul\\\":\\n scale = get_tensor(inits, prev.input[1])\\n scale = scale.flatten().tolist()\\n else:\\n scale = [1.0]\\n if len(scale) > 1:\\n raise NotImplementedError(\\\"Broadcast scale not implemented for softmax\\\")\\n\\n shapes = input_shapes\\n channels, m, n = shape3d(output_shape)\\n softmax_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n 'scale': scale,\\n 'size': len(scale),\\n }\\n network['layers'].append(softmax_layer)\\n\\n # softmax_sublayer = {u'op_type': u'Softmax', 'scale': 1.0}\\n # previous['sublayers'].append(softmax_sublayer)\\n # previous['output_id'] = output_id\\n # print('warning SOFTMAX ignored!... fine if last layer and sorting outputs')\\n\\n elif node.op_type == \\\"Transpose\\\":\\n shapes = input_shapes\\n\\n channels, m, n = shape3d(output_shape)\\n permutation =[p-1 for p in get_attr(node, 'perm')[1:]]\\n transpose_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n 'permutation':permutation,\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(transpose_layer)\\n else:\\n raise RuntimeError('Unknown node type:{} '.format(node.op_type))\\n\\n idx += 1\\n if idx > last_idx:\\n break\\n\\n unsigned_network_inputs = input_type == np.uint8\\n\\n if CVI_1x1:\\n network = mxp_gemm_to_conv(network)\\n\\n network = mxp_set_replay(network, io_info)\\n network = mxp_set_cvi(network)\\n network = mxp_set_unsigned(network, unsigned_network_inputs)\\n\\n if inline_depthwise:\\n network = mxp_inline_depthwise(network)\\n\\n network = mxp_describe_layers(network)\\n network = mxp_number_buffers(network)\\n buffers = mxp_size_buffers(network)\\n network = mxp_number_sublayers(network)\\n\\n network['num_layers'] = len(network['layers'])\\n network['buffers'] = buffers\\n\\n return network\",\n \"def generate(self):\\n self.generate_points()\\n self.generate_edges()\",\n \"def make_matrix():\\n\\n # this imports category, category, data, text, pptx_data\\n\\n if use_test_data:\\n # make a test matrix using create_test_matrix\\n m = matrixfuncs.create_test_matrix()\\n\\n else:\\n # make a matrix by connecting to Slides! and connecting to a data\\n # table.\\n import transformations.utils.slidesconf as slidesconf\\n from Forgetdata.Matrix import ConnectionDefinition\\n conn = ConnectionDefinition()\\n conn.ConnectionString = mtd_filepath # set at top of file\\n conn.Name = \\\"Test\\\"\\n conn.Provider = \\\"SPSS MTD File\\\"\\n liveConnection = slidesconf.connect(conn.ConnectionString,\\n name=conn.Name,\\n provider_name=conn.Provider)\\n\\n m = liveConnection[table_selected]\\n\\n x = tr.MatrixManipulator(m)\\n matrixfuncs.printMatrix(m)\\n\\n for c in m[0]:\\n c.TopMember.Label = c.TopMember.Label.encode('ascii', 'ignore')\\n\\n return m, x\",\n \"def create_matrix(self):\\n import random\\n random.seed()\\n #pecas_disponiveis = [\\\"escudo\\\", \\\"espada\\\", \\\"espada_dupla\\\", \\\"machadinha\\\", \\\"adaga\\\", \\\"punhais\\\"]\\n pecas_disponiveis = [\\\"escudo\\\", \\\"punhais\\\", \\\"espada_dupla\\\", \\\"machadinha\\\", \\\"adaga\\\"]\\n x_start, y_start = 10, self.running.top_bar\\n x, y = x_start, y_start\\n anterior_esq = [None] * self.running.linhas\\n anterior_acima = None\\n\\n for i in range(self.running.colunas):\\n coluna = []\\n for j in range(self.running.linhas):\\n possiveis_escolhas = pecas_disponiveis.copy()\\n if possiveis_escolhas.count(anterior_esq[j]) > 0: possiveis_escolhas.remove(anterior_esq[j])\\n if possiveis_escolhas.count(anterior_acima) > 0 : possiveis_escolhas.remove(anterior_acima)\\n \\n e_type = random.choice(possiveis_escolhas)\\n tile = Tile(self.game, x, y, e_type)\\n coluna.append(tile)\\n self.running.game_images.append(tile.game_image)\\n y += self.running.y_space\\n anterior_esq[j] = e_type\\n anterior_acima = e_type\\n self.running.tabuleiro.append(coluna)\\n x += self.running.x_space\\n y = y_start\\n return\",\n \"def create_dev_matrix(self):\\n if os.path.exists(self.dev_matrix_h5_path):\\n print(\\\"[LOGGING]: \\\" + self.dev_matrix_h5_path + \\\" exists!\\\")\\n return\\n\\n with h5py.File(self.dev_matrix_h5_path, 'w') as f:\\n\\n for mode in ['train', 'test']:\\n for device in ['a', 'b', 'c']:\\n grp = f.create_group(mode + '/' + device)\\n grp['data'], grp['label'] = self.extract_npy(mode=mode, devices=device)\\n # add parallel data as separate device p\\n grp = f.create_group(mode + '/p')\\n grp['data'], grp['label'] = self.extrac_para_npy(mode=mode)\\n\\n # add neg parallel data as device A\\n grp = f.create_group(mode + '/A')\\n grp['data'], grp['label'] = self.extract_neg_para_npy(mode=mode)\\n f.close()\",\n \"def _generate_adjacency_matrices(self):\\n self.adj_matrices = dict()\\n mes = []\\n args = []\\n for metaedge in self.metaedges:\\n mes.append(metaedge)\\n args.append(self._prepare_parallel_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\\n front_num=0)\\n for metaedge, matrix in zip(mes, res):\\n self.adj_matrices[metaedge] = matrix\",\n \"def output_rule_feature_matrices():\\n with open(config.data_path + config.sentiment_seed, 'rb') as input_file:\\n sentiment_dict = pickle.load(input_file)\\n seed_sentiments = set(sentiment_dict.keys())\\n \\n for i in range(len(config.file_names)):\\n if i is 5:\\n print('processing ', config.file_names[i])\\n fname = config.file_names[i]\\n feature_x, feature_y, opinion_x, opinion_y = text_to_matrix(\\n fname, seed_sentiments)\\n feature_x = np.transpose(feature_x)\\n opinion_x = np.transpose(opinion_x)\\n with open('../results/' + fname + '_rule_feature_matrix.pickle', 'wb') as f:\\n pickle.dump(feature_x, f)\\n with open('../results/' + fname + '_rule_opinion_matrix.pickle', 'wb') as f:\\n pickle.dump(opinion_x, f)\\n\\n with open('../results/' + fname + '_feature_label.pickle', 'wb') as f:\\n pickle.dump(feature_y.ravel(), f)\\n with open('../results/' + fname + '_opinion_label.pickle', 'wb') as f:\\n pickle.dump(opinion_y.ravel(), f)\",\n \"def get_linear_discrete_matrices(self):\\n\\n vf_op, vb_op = get_operating_point_inputs(self.operating_point[1], self.model_type)\\n if self.model_type == ModelType.EASY:\\n At, Bt, Vf_op, Vd_op = getLinearizedMatrices(self.model_type, self.operating_point[0:6], vf_op, vb_op)\\n elif self.model_type == ModelType.GYROMOMENT:\\n At, Bt = get_gyro_matrices(self.operating_point, self.operating_point[6] / mc.K_f, vf_op, vb_op)\\n if self.model_type == ModelType.EASY:\\n Ct = np.array([[1, 0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0, 0]])\\n Dt = np.array([[0, 0],\\n [0, 0],\\n [0, 0]])\\n elif self.model_type == ModelType.GYROMOMENT:\\n if self.nOutputs == 3:\\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0, 0, 0, 0]])\\n Dt = np.array([[0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0]])\\n elif self.nOutputs == 5:\\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 1, 0],\\n [0, 0, 0, 0, 0, 0, 0, 1]])\\n Dt = np.array([[0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0]])\\n\\n Ak, Bk, Ck, Dk = discretize_linear_state_space(At, Bt, Ct, Dt, self.timeStep)\\n return Ak, Bk, Ck, Dk\",\n \"def make_input_materials(self) :\\n # 1 5 1 MATERIAL 1 (arbitrary line, i think) \\n # 1.4493e+00 9.9000e-03 7.9000e-03 1. 0. 0. 7.9000e-03 1.\\n # 3.8070e-01 1.0420e-01 1.6920e-01 0 1.5100e-02 0. 1.6920e-01 1.\\n self.input_materials = \\\"\\\"\\n number_mats = len(self.core.pattern)+1\\n a = self.core.assemblies\\n for i in range(0, number_mats-1) :\\n # Row 1: description.\\n self.input_materials += \\\" \\\" + str(i+1) + \\\" 5 1 MATERIAL \\\" + \\\\\\n str(i+1) + \\\" (\\\" + \\\\\\n a[i].model + \\\", \\\" + \\\\\\n str(a[i].enrichment) + \\\" w/o, \\\" + \\\\\\n str(a[i].burnup) + \\\" MWd/kg)\\\\n\\\" \\n # Rows 2 and 3.\\n D1,D2,A1,A2,F1,F2,S12 = a[i].get_constants()\\n d = np.array([[D1,A1,F1,1.0,0.0,0.0,F1,1.0],[D2,A2,F2,0.0,S12,0.0,F2,1.0]])\\n for j in range(0, 2) :\\n for k in range(0, 8) :\\n self.input_materials +='%12.4e' %(d[j,k])\\n self.input_materials += '\\\\n'\\n \\n a = self.core.reflector\\n # Row 1: description.\\n self.input_materials += \\\" \\\" + str(number_mats) + \\\" 5 1 MATERIAL \\\" + \\\\\\n str(number_mats) + \\\" (REFLECTOR) \\\\n\\\" \\n # Rows 2 and 3.\\n D1,D2,A1,A2,F1,F2,S12 = a.get_constants()\\n d = np.array([[D1,A1,F1,1.0,0.0,0.0,F1,1.0],[D2,A2,F2,0.0,S12,0.0,F2,1.0]])\\n for i in range(0, 2) :\\n for j in range(0, 8) :\\n self.input_materials +='%12.4e' %(d[i,j])\\n self.input_materials += '\\\\n'\\n self.input_materials += \\\"WHITE\\\\n\\\" + \\\"BLACK\\\\n\\\" + \\\"END\\\\n\\\"\",\n \"def create_weight_matrices(self):\\n rad = 1 / np.sqrt(self.no_of_in_nodes)\\n X = truncated_normal(mean=0, \\n sd=1, \\n low=-rad, \\n upp=rad)\\n self.wih = X.rvs((self.no_of_hidden_nodes, \\n self.no_of_in_nodes))\\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\\n self.who = X.rvs((self.no_of_out_nodes, \\n self.no_of_hidden_nodes))\",\n \"def _calc_matrix(self):\\n\\t\\tz = self.zoom\\n\\t\\talloc = self.allocation\\n\\t\\tif self.image:\\n\\t\\t\\tiw, ih = self.image.get_width(), self.image.get_height()\\n\\t\\telse:\\n\\t\\t\\tiw, ih = 0, 0\\n#\\t\\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\\n\\t\\t\\n\\t\\ti2w = cairo.Matrix(\\n\\t\\t\\tz,0,\\n\\t\\t\\t0,z,\\n\\t\\t\\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \\n\\t\\t\\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\\n\\t\\t\\t)\\n\\t\\t\\n\\t\\tself._i2w_matrix = i2w\\n\\t\\t\\n\\t\\tw2i = cairo.Matrix(*i2w) #copy\\n\\t\\tw2i.invert()\\n\\t\\tself._w2i_matrix = w2i\",\n \"def _build_model(self):\\n\\n with tf.variable_scope(\\\"Matchnet\\\", reuse=tf.AUTO_REUSE):\\n # For determining the runtime shape\\n x_shp = tf.shape(self.x_in)\\n\\n # -------------------- Network archintecture --------------------\\n # Build graph\\n print(\\\"Building Graph\\\")\\n self.logits = build_graph(self.x_in, self.is_training, self.config)\\n # ---------------------------------------------------------------\\n\\n # Turn into weights for each sample\\n weights = tf.nn.relu(tf.tanh(self.logits))\\n\\n # Make input data (num_img_pair x num_corr x 4)\\n xx = tf.transpose(tf.reshape(\\n self.x_in, (x_shp[0], x_shp[2], 4)), (0, 2, 1))\\n\\n # Create the matrix to be used for the eight-point algorithm\\n X = tf.transpose(tf.stack([\\n xx[:, 2] * xx[:, 0], xx[:, 2] * xx[:, 1], xx[:, 2],\\n xx[:, 3] * xx[:, 0], xx[:, 3] * xx[:, 1], xx[:, 3],\\n xx[:, 0], xx[:, 1], tf.ones_like(xx[:, 0])\\n ], axis=1), (0, 2, 1))\\n print(\\\"X shape = {}\\\".format(X.shape))\\n wX = tf.reshape(weights, (x_shp[0], x_shp[2], 1)) * X\\n print(\\\"wX shape = {}\\\".format(wX.shape))\\n XwX = tf.matmul(tf.transpose(X, (0, 2, 1)), wX)\\n print(\\\"XwX shape = {}\\\".format(XwX.shape))\\n\\n # Recover essential matrix from self-adjoing eigen\\n e, v = tf.self_adjoint_eig(XwX)\\n self.e_hat = tf.reshape(v[:, :, 0], (x_shp[0], 9))\\n # Make unit norm just in case\\n self.e_hat /= tf.norm(self.e_hat, axis=1, keep_dims=True)\",\n \"def build_augmented_matrix(self):\\r\\n for row in range(self.SIZE):\\r\\n self.matrix[row].append(self.result[row])\",\n \"def generate(self):\\n self.training_data.gen_x(self.x_func)\\n self.training_data.gen_a(self.a_func)\\n self.training_data.gen_y(self.y_func)\\n \\n self.testing_data.gen_x(self.x_func)\\n self.testing_data.gen_ys(self.y_func)\\n self.testing_data.gen_azero(self.ytotal_func)\",\n \"def build_modules(self):\\n self.backbone = Backbone(\\n self.configs['backbone'],\\n freeze_backbone=self.configs['freeze_backbone'],\\n freeze_batchnorm=True\\n )\\n\\n backbone_channel_sizes = get_backbone_channel_sizes(self.backbone)\\n\\n self.fpn = FeaturePyramidNetwork(\\n backbone_channel_sizes=backbone_channel_sizes,\\n min_feature_level=self.configs['min_feature_level'],\\n max_feature_level=self.configs['max_feature_level'],\\n feature_size=self.configs['pyramid_feature_size']\\n )\\n\\n self.shared_conv_model = SharedConvModel(\\n input_feature_size=self.configs['pyramid_feature_size'],\\n feature_size=self.configs['shared_conv_feature_size'],\\n num_layers=self.configs['shared_conv_num_layers']\\n )\\n\\n if self.configs['shared_conv_num_layers'] > 0:\\n shared_conv_output_size = self.configs['shared_conv_feature_size']\\n else:\\n shared_conv_output_size = self.configs['pyramid_feature_size']\\n\\n self.ofn = ObjectFinderNetwork(\\n input_feature_size=shared_conv_output_size,\\n feature_size=self.configs['finder_feature_size'],\\n num_layers=self.configs['finder_num_layers']\\n )\\n\\n self.ofn_loss_fn\\n\\n # self.classification_model = ClassificationModel()\\n #\\n # self.regression_model = RegressionModel()\",\n \"def build(node):\\n yield Matrix(node[Matrix.TAG])\",\n \"def createMatrices(file, word2Idx, maxSentenceLen, extendMapping, labelsMapping, aspectMapping, typeMapping, tenseMapping, eventClassMapping, distanceMapping, sentenceLengthMapping):\\n labels = []\\n eventMatrix = []\\n timeMatrix = []\\n\\n sentenceLengths = []\\n sentenceMatrix = []\\n positionMatrix_e = []\\n positionMatrix_t = []\\n\\n aspectMatrix = []\\n typeMatrix = []\\n tenseMatrix = []\\n eventClassMatrix = []\\n featuresList = []\\n \\n \\n minDistance = 0\\n for distanceKey in distanceMapping.iterkeys():\\n if isinstance(distanceKey, (int, long)):\\n minDistance = min(minDistance, int(distanceKey))\\n \\n for line in open(file):\\n features = eval(line.strip())\\n featuresList.append(features)\\n label = features['label']\\n event = features[\\\"Token[0]\\\"]\\n eventPosition = int(features[\\\"eventPosition\\\"])\\n tokens = features[\\\"textInBetween\\\"] if \\\"textInBetween\\\" in features else features[\\\"sentence\\\"]\\n \\n aspect = features[\\\"aspect\\\"]\\n tense = features[\\\"tense\\\"]\\n eventClass = features[\\\"eventClass\\\"]\\n \\n labels.append(labelsMapping[label.lower()] if label.lower() in labelsMapping else -1)\\n eventMatrix.append(getWordIdx(event, word2Idx))\\n \\n aspectMatrix.append(getMappingIdx(aspect, aspectMapping, extendMapping))\\n tenseMatrix.append(getMappingIdx(tense, tenseMapping, extendMapping))\\n eventClassMatrix.append(getMappingIdx(eventClass, eventClassMapping, extendMapping))\\n \\n if 'TimeTokenFirst' in features:\\n time = features['TimeTokenFirst']\\n timeMatrix.append(getWordIdx(time, word2Idx))\\n \\n if 'type' in features:\\n type = features[\\\"type\\\"]\\n typeMatrix.append(getMappingIdx(type, typeMapping, extendMapping))\\n \\n timePosition = int(features[\\\"timeFirstPosition\\\"]) if 'timeFirstPosition' in features else 0\\n \\n\\n if len(tokens) in sentenceLengthMapping:\\n sentenceLengths.append(sentenceLengthMapping[len(tokens)])\\n else:\\n sentenceLengths.append(sentenceLengthMapping['GreaterMax'])\\n\\n \\n tokenIds = np.zeros(maxSentenceLen)\\n positionValues_e = np.zeros(maxSentenceLen)\\n positionValues_t = np.zeros(maxSentenceLen)\\n for idx in xrange(0, min(maxSentenceLen, len(tokens))):\\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\\n \\n distance_e = idx - eventPosition\\n distance_t = idx - timePosition\\n\\n if distance_e in distanceMapping:\\n positionValues_e[idx] = distanceMapping[distance_e]\\n elif distance_e <= minDistance:\\n positionValues_e[idx] = distanceMapping['LowerMin']\\n else:\\n positionValues_e[idx] = distanceMapping['GreaterMax']\\n \\n if distance_t in distanceMapping:\\n positionValues_t[idx] = distanceMapping[distance_t]\\n elif distance_t <= minDistance:\\n positionValues_t[idx] = distanceMapping['LowerMin']\\n else:\\n positionValues_t[idx] = distanceMapping['GreaterMax']\\n\\n sentenceMatrix.append(tokenIds)\\n positionMatrix_e.append(positionValues_e)\\n positionMatrix_t.append(positionValues_t)\\n\\n \\n labels = np.array(labels, dtype='int32')\\n eventMatrix = np.expand_dims(np.array(eventMatrix, dtype='int32'), axis=1)\\n timeMatrix = np.expand_dims(np.array(timeMatrix, dtype='int32'), axis=1)\\n aspectMatrix = np.expand_dims(np.array(aspectMatrix, dtype='int32'), axis=1)\\n typeMatrix = np.expand_dims(np.array(typeMatrix, dtype='int32'), axis=1)\\n tenseMatrix = np.expand_dims(np.array(tenseMatrix, dtype='int32'), axis=1)\\n eventClassMatrix = np.expand_dims(np.array(eventClassMatrix, dtype='int32'), axis=1)\\n sentenceLengths = np.expand_dims(np.array(sentenceLengths, dtype='int32'), axis=1)\\n \\n \\n sentenceMatrix = np.array(sentenceMatrix, dtype='int32')\\n positionMatrix_e = np.array(positionMatrix_e, dtype='int32')\\n positionMatrix_t = np.array(positionMatrix_t, dtype='int32')\\n \\n\\n\\n return {'labels': labels,\\n 'event':eventMatrix, \\n 'time':timeMatrix, \\n 'sentence':sentenceMatrix, \\n 'positions_e':positionMatrix_e, \\n 'positions_t':positionMatrix_t, \\n 'aspect':aspectMatrix, \\n 'tense':tenseMatrix, \\n 'eventClass':eventClassMatrix, \\n 'type': typeMatrix,\\n 'sentence_len': sentenceLengths,\\n 'features': featuresList}\",\n \"def run(self):\\n # load_data\\n layers = self.load_all_data() # list of tuples (file_name, feature_matrix)\\n\\n # check variable types\\n if len(self.method) == 1:\\n self.method = [self.method[0]] * len(layers)\\n elif len(layers) != len(self.method):\\n raise ValueError(\\\"Number of matrices extracted from input files and number of similarity methods \\\" +\\n \\\"does not correspond\\\")\\n\\n # check missing value parameter\\n if len(self.missing) == 1:\\n self.logger.info(\\\"#Setting all 'missing' parameters to {}\\\".format(self.missing[0]))\\n self.missing = [self.missing[0]] * len(layers)\\n elif len(layers) != len(self.missing):\\n raise ValueError(\\\"Number of matrices extracted from input files and number of given missing parameters \\\" +\\n \\\"does not correspond\\\")\\n\\n # extract sample names\\n all_samples = set()\\n for layer_data in layers:\\n all_samples = all_samples.union({name for name in layer_data[1].columns})\\n self.logger.info(\\\"#Total number of unique samples: {}\\\".format(len(all_samples)))\\n\\n out_arrays = {}\\n adj_matrices = []\\n\\n # create adjacency matrices\\n for i in range(len(layers)):\\n self.logger.info(\\\"#Layer: {}\\\".format(i))\\n layer_data = layers[i][1]\\n\\n # add missing samples layer\\n samples = {name for name in layer_data.columns}\\n for name in all_samples - samples:\\n layer_data[name] = np.nan\\n\\n # sort data frame by sample names\\n layer_data.sort_index(axis=1, inplace=True)\\n\\n # extract feature matrices\\n f = layer_data.values.T\\n self.logger.info(\\\"Feature matrix: ({} samples x {} features)\\\".format(f.shape[0], f.shape[1]))\\n\\n # check if feature matrix values are correct\\n ncat = check_categories(f)\\n if ncat != [0, 1]:\\n standardized = is_standardized(f, axis=0, atol=self.atol)\\n if not standardized[0]:\\n raise ValueError(\\\"Incorrect values in feature matrix. Mean of features in \\\" +\\n \\\"({},{}) \\\".format(round(standardized[1][0], 3), round(standardized[1][1], 3)) +\\n \\\"range. Standard deviation of features in \\\" +\\n \\\"({}, {}) \\\".format(round(standardized[2][0], 3), round(standardized[2][1], 3)) +\\n \\\"range. Please, supply either binary dataset \\\" +\\n \\\"(0 or 1 feature values) or continuous values standardized feature-wise. \\\" +\\n \\\"Alternatively for almost standardized continuous data, \\\" +\\n \\\"increase '-atol' parameter value (currently {}).\\\".format(self.atol))\\n else:\\n self.logger.debug(\\\"Data is correctly standardized\\\")\\n else:\\n self.logger.debug(\\\"Found two unique categories in data: [0, 1]\\\")\\n if self.method[i] != 'cosine':\\n self.logger.info(\\\"Using '{}' similarity for [0, 1] data. \\\".format(self.method[i]) +\\n \\\"Suggested better measure: cosine similarity.\\\")\\n\\n # create adjacency matrix\\n a = feature_to_adjacency(f, missing=self.missing[i], method=self.method[i], n=self.k, alpha=self.alpha)\\n self.logger.info('Adjacency matrix {} created [similarity method: {}]'.format(a.shape, self.method[i]))\\n\\n # plot adjacency matrix\\n plot_path = self.plot_base + \\\"_\\\" + str(i) + \\\".png\\\" if self.plot else self.plot_base\\n plot_heatmap_seaborn(a, title=\\\"Layer {} (source:{})\\\".format(i, layers[i][0]), file_path=plot_path)\\n if self.plot:\\n self.logger.info(\\\"Adjacency matrix plot saved to {}\\\".format(plot_path))\\n\\n # add matrices to output arrays\\n out_arrays[str(i)] = a\\n adj_matrices.append(a)\\n out_arrays[\\\"f\\\" + str(i)] = f\\n\\n # check if there are samples not accessible in any layer\\n missing_samples = []\\n for a in adj_matrices:\\n missing_samples += [i for i in range(a.shape[1]) if np.all(np.isnan(a[:, i]))]\\n\\n samples_to_drop = [sample for sample, val in Counter(missing_samples).items() if val == len(adj_matrices)]\\n if samples_to_drop:\\n # drop inaccessible samples\\n self.logger.info(\\\"Found samples inaccessible in every layer of graph. \\\" +\\n \\\"Try changing '-missing' parameter or inspect your data \\\")\\n sample_names = np.array(sorted(list(all_samples)))[np.array(samples_to_drop)]\\n self.logger.info(\\\"Dropped samples: {}\\\".format(list(sample_names)))\\n updated_out_arrays = {}\\n selector = np.array([x for x in range(len(all_samples)) if x not in samples_to_drop])\\n for i in range(len(out_arrays.keys())):\\n if str(i) not in out_arrays.keys():\\n break\\n updated_out_arrays[str(i)] = out_arrays[str(i)][selector[:, None], selector]\\n updated_out_arrays[\\\"f\\\" + str(i)] = out_arrays[\\\"f\\\" + str(i)][selector, :]\\n\\n # create output file\\n updated_out_arrays[\\\"samples\\\"] = np.array(sorted(list(all_samples)))[selector]\\n save_arrays_to_npz(data=updated_out_arrays, file_path=self.outfile)\\n\\n else:\\n # create output file\\n out_arrays[\\\"samples\\\"] = np.array(sorted(list(all_samples)))\\n save_arrays_to_npz(data=out_arrays, file_path=self.outfile)\\n\\n self.logger.info(\\\"#Output file {} created\\\".format(self.outfile))\",\n \"def build_generator2D_(self, model_shape, filters=32, k_size=4, z_size=500, summary=False, model_file=None, name='gan_g_'):\\n if (model_file):\\n \\\"\\\"\\\"\\n Load pretreined model\\n \\\"\\\"\\\"\\n model = self.utils.build_pretrained_model(model_file)\\n if (summary):\\n model.summary()\\n return model\\n else:\\n\\n n_rows = model_shape[0]\\n n_cols = model_shape[1]\\n c_dims = model_shape[2]\\n input_shape = (z_size,)\\n if n_rows % 8 !=0:\\n height = n_rows//8 + 1\\n else:\\n height = n_rows//8\\n if n_cols % 8 !=0:\\n width = n_cols//8 +1\\n else:\\n width = n_cols//8\\n \\n num_init_neurons = 8*filters \\n reshape_size= (height, width, num_init_neurons)\\n \\n # 8*height, 4*height, 2*height, height = n_rows, n_rows//2, n_rows//4, n_rows//8\\n rows_matching = np.equal([2*height, 4*height, 8*height], [n_rows//4, n_rows//2, n_rows])\\n index_rows = np.where(np.logical_not(rows_matching))[0]\\n if len(index_rows) > 0:\\n index_rows = index_rows[0]\\n # print(index_rows)\\n # 8*width, 4*width, 2*width, width = n_cols//1, n_cols//2, n_cols//4, n_cols//8\\n cols_matching = np.equal([2*width, 4*width, 8*width], [n_cols//4, n_cols//2, n_cols])\\n index_cols = np.where(np.logical_not(cols_matching))[0]\\n if len (index_cols) > 0:\\n index_cols = index_cols[0]\\n # print(index_cols)\\n\\n input_layer = Input(shape=input_shape, name=name+'input')\\n g = Dense(width * height * num_init_neurons, kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(input_layer)\\n g = Reshape(reshape_size, name=name+'reshape')(g)\\n g = BatchNormalization(momentum=0.8, name=name+'bn_dense')(g, training=True)\\n g = Activation(activation='relu', name=name+'relu')(g)\\n\\n g = self.Conv2DTranspose_Block(g, 4*filters, name=name+'1')\\n if index_rows==0 or index_cols==0:\\n g = BilinearUpsampling(output_size=(n_rows//4, n_cols//4), name=name+'bilinear')(g)\\n g = self.Conv2DTranspose_Block(g, 2*filters, k_size=k_size, name=name+'2')\\n if index_rows==1 or index_cols==1:\\n g = BilinearUpsampling(output_size=(n_rows//2, n_cols//2), name=name+'bilinear')(g)\\n g = self.Conv2DTranspose_Block(g, 1*filters, k_size=k_size, name=name+'3')\\n if index_rows==2 or index_cols==2:\\n g = BilinearUpsampling(output_size=(n_rows, n_cols), name=name+'bilinear')(g) \\n g = self.Conv2DTranspose_Block(g, c_dims, strides=1, activation='tanh', k_size=k_size, name=name+'4', bn=False)\\n\\n model = Model(inputs=[input_layer], outputs=[g], name='Generator')\\n if (summary):\\n model.summary()\\n return model\",\n \"def __init__(\\n self,\\n numpy_rng,\\n train_set_x,\\n train_set_y,\\n hidden_layers_sizes,\\n n_ins=784,\\n n_outs=10\\n ):\\n\\n self.sigmoid_layers = []\\n self.AE_layers = []\\n self.params = []\\n self.n_layers = len(hidden_layers_sizes)\\n self.train_set_x = train_set_x\\n self.train_set_y = train_set_y\\n\\n assert self.n_layers > 0\\n\\n self.x = T.matrix('x') # the data is presented as rasterized images\\n self.y = T.ivector('y') # the labels are presented as 1D vector of\\n\\n for i in xrange(self.n_layers): # used to be n layers\\n\\n # construct the sigmoid layer = encoder stack\\n if i == 0:\\n layer_input = self.x\\n else:\\n layer_input = self.sigmoid_layers[-1].output\\n\\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\\n input=layer_input,\\n n_in=(n_ins if i == 0 else\\n hidden_layers_sizes[i-1]),\\n n_out=hidden_layers_sizes[i],\\n activation=T.nnet.sigmoid)\\n\\n # add the layer to our list of layers\\n self.sigmoid_layers.append(sigmoid_layer)\\n self.params.extend(sigmoid_layer.params)\\n\\n # init the DA_layer, takes weights from sigmoid layer\\n AE_layer = AutoEncoder(\\n numpy_rng=numpy_rng,\\n input=layer_input,\\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\\n n_hidden=hidden_layers_sizes[i],\\n W=sigmoid_layer.W,\\n bhid=sigmoid_layer.b)\\n\\n self.AE_layers.append(AE_layer)\\n\\n # on top of the layers\\n # log layer for fine-tuning\\n self.logLayer = LogisticRegression(\\n input=self.sigmoid_layers[-1].output,\\n n_in=hidden_layers_sizes[-1],\\n n_out=n_outs\\n )\\n self.params.extend(self.logLayer.params)\\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\\n self.errors = self.logLayer.errors(self.y)\",\n \"def generate(self):\\n t_0 = time()\\n\\n if self.random_towers:\\n self.towers = np.random.rand(self.number_towers, 2)\\n else:\\n step = np.ceil(np.sqrt(self.number_towers)).astype('int')\\n\\n if step ** 2 != self.number_towers:\\n self.number_towers = step ** 2\\n print(f'WARNING: number of towers changed to {self.number_towers}')\\n\\n X, Y = np.mgrid[0:1:step * 1j, 0:1:step * 1j]\\n positions = np.vstack([X.ravel(), Y.ravel()])\\n self.towers = positions.swapaxes(1, 0)\\n\\n self.towers_manager = TowersManager(self.towers, self.vel_friction)\\n\\n self.distances = self.towers_manager.generate_distances()\\n self.print(f'Took {time() - t_0} to create distrances matrix')\\n\\n t = time()\\n self.probabilities = self.generate_probabilities()\\n self.print(f'Took {time() - t} to create probabilities matrix')\\n\\n t = time()\\n self.traces = self.generate_weighted_users_traces()\\n self.print(f'Took {time() - t} to create user traces')\\n\\n t = time()\\n self.aggregated_data = self.generate_aggregate_data()\\n self.print(f'Took {time() - t} to build aggregated data')\\n\\n self.print(f'Took {time() - t_0} to generate all')\",\n \"def convert(self):\\n self.tilewidth = int(self.tilewidth)\\n self.tileheight = int(self.tileheight)\\n self.width = int(self.width)\\n self.height = int(self.height)\\n self.pixel_width = self.width * self.tilewidth\\n self.pixel_height = self.height * self.tileheight\\n for layer in self.layers:\\n self.named_layers[layer.name] = layer\\n layer.opacity = float(layer.opacity)\\n layer.x = int(layer.x)\\n layer.y = int(layer.y)\\n layer.width = int(layer.width)\\n layer.height = int(layer.height)\\n layer.pixel_width = layer.width * self.tilewidth\\n layer.pixel_height = layer.height * self.tileheight\\n layer.visible = bool(int(layer.visible))\\n for tile_set in self.tile_sets:\\n self.named_tile_sets[tile_set.name] = tile_set\\n tile_set.spacing = int(tile_set.spacing)\\n tile_set.margin = int(tile_set.margin)\\n for img in tile_set.images:\\n if img.trans:\\n img.trans = (int(img.trans[:2], 16), int(img.trans[2:4], 16), int(img.trans[4:], 16))\\n for obj_group in self.object_groups:\\n obj_group.x = int(obj_group.x)\\n obj_group.y = int(obj_group.y)\\n obj_group.width = int(obj_group.width)\\n obj_group.height = int(obj_group.height)\\n for map_obj in obj_group.objects:\\n map_obj.x = int(map_obj.x)\\n map_obj.y = int(map_obj.y)\\n map_obj.width = int(map_obj.width)\\n map_obj.height = int(map_obj.height)\",\n \"def convert(self):\\n self.tilewidth = int(self.tilewidth)\\n self.tileheight = int(self.tileheight)\\n self.width = int(self.width)\\n self.height = int(self.height)\\n self.pixel_width = self.width * self.tilewidth\\n self.pixel_height = self.height * self.tileheight\\n for layer in self.layers:\\n self.named_layers[layer.name] = layer\\n layer.opacity = float(layer.opacity)\\n layer.x = int(layer.x)\\n layer.y = int(layer.y)\\n layer.width = int(layer.width)\\n layer.height = int(layer.height)\\n layer.pixel_width = layer.width * self.tilewidth\\n layer.pixel_height = layer.height * self.tileheight\\n layer.visible = bool(int(layer.visible))\\n for tile_set in self.tile_sets:\\n self.named_tile_sets[tile_set.name] = tile_set\\n tile_set.spacing = int(tile_set.spacing)\\n tile_set.margin = int(tile_set.margin)\\n for img in tile_set.images:\\n if img.trans:\\n img.trans = (int(img.trans[:2], 16), int(img.trans[2:4], 16), int(img.trans[4:], 16))\\n for obj_group in self.object_groups:\\n obj_group.x = int(obj_group.x)\\n obj_group.y = int(obj_group.y)\\n obj_group.width = int(obj_group.width)\\n obj_group.height = int(obj_group.height)\\n for map_obj in obj_group.objects:\\n map_obj.x = int(map_obj.x)\\n map_obj.y = int(map_obj.y)\\n map_obj.width = int(map_obj.width)\\n map_obj.height = int(map_obj.height)\",\n \"def create_matrix(self):\\n\\n self.matrix = np.zeros((len(self.users), len(self.items)))\\n\\n for user in self.train_set['users']:\\n for item in self.train_set['feedback'][user]:\\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\\\\n self.train_set['feedback'][user][item]\",\n \"def build_generator2D(self, model_shape, filters=32, k_size=4, z_size=500, summary=False, model_file=None, name='gan_g_'):\\n if (model_file):\\n \\\"\\\"\\\"\\n Load pretreined model\\n \\\"\\\"\\\"\\n model = self.utils.build_pretrained_model(model_file)\\n if (summary):\\n model.summary()\\n return model\\n else:\\n\\n n_rows = model_shape[0]\\n n_cols = model_shape[1]\\n input_shape = (z_size,)\\n if n_rows % 8 !=0:\\n height = n_rows//8 + 1\\n else:\\n height = n_rows//8\\n if n_cols % 8 !=0:\\n width = n_cols//8 +1\\n else:\\n width = n_cols//8\\n \\n num_init_neurons = 8*filters \\n reshape_size= (height, width, num_init_neurons)\\n \\n # 8*height, 4*height, 2*height, height = n_rows, n_rows//2, n_rows//4, n_rows//8\\n rows_matching = np.equal([2*height, 4*height, 8*height], [n_rows//4, n_rows//2, n_rows])\\n index_rows = np.where(np.logical_not(rows_matching))[0]\\n if len(index_rows) > 0:\\n index_rows = index_rows[0]\\n # print(index_rows)\\n # 8*width, 4*width, 2*width, width = n_cols//1, n_cols//2, n_cols//4, n_cols//8\\n cols_matching = np.equal([2*width, 4*width, 8*width], [n_cols//4, n_cols//2, n_cols])\\n index_cols = np.where(np.logical_not(cols_matching))[0]\\n if len (index_cols) > 0:\\n index_cols = index_cols[0]\\n # print(index_cols)\\n\\n input_layer = Input(shape=input_shape, name=name+'input')\\n g = Dense(width * height * num_init_neurons, kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(input_layer)\\n g = Reshape(reshape_size, name=name+'reshape')(g)\\n g = BatchNormalization(momentum=0.8, name=name+'bn_dense')(g, training=True)\\n g = Activation(activation='relu', name=name+'relu')(g)\\n\\n g = self.Conv2DTranspose_Block(g, 4*filters, name=name+'1')\\n if index_rows==0 or index_cols==0:\\n g = BilinearUpsampling(output_size=(n_rows//4, n_cols//4), name=name+'bilinear')(g)\\n g = self.Conv2DTranspose_Block(g, 2*filters, k_size=k_size, name=name+'2')\\n if index_rows==1 or index_cols==1:\\n g = BilinearUpsampling(output_size=(n_rows//2, n_cols//2), name=name+'bilinear')(g)\\n g = self.Conv2DTranspose_Block(g, 1*filters, k_size=k_size, name=name+'3')\\n if index_rows==2 or index_cols==2:\\n g = BilinearUpsampling(output_size=(n_rows, n_cols), name=name+'bilinear')(g) \\n g = self.Conv2DTranspose_Block(g, 2, strides=1, activation='tanh', k_size=k_size, name=name+'4', bn=False)\\n\\n model = Model(inputs=[input_layer], outputs=[g], name='Generator')\\n if (summary):\\n model.summary()\\n return model\",\n \"def MeshMachine(main):\\n\\n # oDesign definition\\n oDesign = main['ANSYS']['oDesign']\\n\\n # Data for the rotor mesh\\n RotorName = main['ANSYS']['Rotor&Magnets']['Name'][0]\\n RotorNumMaxElem = main['ANSYS']['Mesh']['Rotor']['NumMaxElem']\\n RotorMaxLength = main['ANSYS']['Mesh']['Rotor']['MaxLength']\\n\\n # Data for the magnets mesh\\n PMNames = main['ANSYS']['Rotor&Magnets']['PMNames']\\n PMNumMaxElem = main['ANSYS']['Mesh']['Magnets']['NumMaxElem']\\n PMMaxLength = main['ANSYS']['Mesh']['Magnets']['MaxLength']\\n\\n # Data for the Stator mesh\\n StatorName = main['ANSYS']['Stator']['Name']\\n StatorNormalDev = main['ANSYS']['Mesh']['Stator']['NormalDev']\\n StatorAspectRatio = main['ANSYS']['Mesh']['Stator']['AspectRatio']\\n\\n # Data for the Stator mesh\\n CoilNames = main['ANSYS']['Winding']['CoilNames']\\n WindingNumMaxElem = main['ANSYS']['Mesh']['Winding']['NumMaxElem']\\n WindingMaxLength = main['ANSYS']['Mesh']['Winding']['MaxLength']\\n\\n WindingName = []\\n for phase in CoilNames:\\n for direction in phase:\\n WindingName += direction\\n\\n # Creating meshes\\n oModule = oDesign.GetModule(\\\"MeshSetup\\\")\\n\\n # Rotor meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Rotor\\\",\\n \\\"RefineInside:=\\\", True,\\n \\\"Enabled:=\\\", True,\\n \\\"Objects:=\\\", [RotorName],\\n \\\"RestrictElem:=\\\", False,\\n \\\"NumMaxElem:=\\\", str(RotorNumMaxElem),\\n \\\"RestrictLength:=\\\", True,\\n \\\"MaxLength:=\\\", str(RotorMaxLength)+\\\"mm\\\"\\n ]\\n )\\n # Magnet meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Magnets\\\",\\n \\\"RefineInside:=\\\", True,\\n \\\"Enabled:=\\\", True,\\n \\\"Objects:=\\\", PMNames,\\n \\\"RestrictElem:=\\\", False,\\n \\\"NumMaxElem:=\\\", str(PMNumMaxElem),\\n \\\"RestrictLength:=\\\", True,\\n \\\"MaxLength:=\\\", str(PMMaxLength)+\\\"mm\\\"\\n ]\\n )\\n # Stator meshes\\n oModule.AssignTrueSurfOp(\\n [\\n \\\"NAME:Stator\\\",\\n \\\"Objects:=\\\", [StatorName],\\n \\\"CurvedSurfaceApproxChoice:=\\\", \\\"ManualSettings\\\",\\n \\\"SurfDevChoice:=\\\", 0,\\n \\\"NormalDevChoice:=\\\", 2,\\n \\\"NormalDev:=\\\", str(StatorNormalDev) + \\\"deg\\\",\\n \\\"AspectRatioChoice:=\\\", 2,\\n \\\"AspectRatio:=\\\", str(StatorAspectRatio)\\n ]\\n )\\n\\n # Coil meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Coils\\\",\\n \\\"RefineInside:=\\\"\\t, True,\\n \\\"Enabled:=\\\"\\t\\t, True,\\n \\\"Objects:=\\\"\\t\\t, WindingName,\\n \\\"RestrictElem:=\\\"\\t, False,\\n \\\"NumMaxElem:=\\\"\\t\\t, str(WindingNumMaxElem),\\n \\\"RestrictLength:=\\\"\\t, True,\\n \\\"MaxLength:=\\\"\\t\\t, str(WindingMaxLength) +\\\"mm\\\"\\n ]\\n )\\n\\n return main\",\n \"def build_mat(self):\\n for row, s in enumerate(self.S):\\n for col, t in enumerate(self.T):\\n\\n if self.symmetric and row > col:\\n pass\\n\\n else:\\n self.mat[row, col] = self.kernel(s, t, self.n)\\n\\n if self.symmetric:\\n self.mat = self.symmetrize(self.mat)\\n else:\\n for idx, s in enumerate(self.S):\\n self.test_normalization[idx] = self.kernel(s, s, self.n)\",\n \"def build(classes):\\n # data input\\n data = mx.sym.Variable(\\\"data\\\")\\n\\n # Block #1: first CONV => RELU => POOL layer set\\n conv1_1 = mx.sym.Convolution(data=data, kernel=(11, 11), stride=(4, 4), num_filter=96)\\n act1_1 = mx.sym.LeakyReLU(data=conv1_1, act_type=\\\"elu\\\")\\n bn1_1 = mx.sym.BatchNorm(data=act1_1)\\n pool1 = mx.sym.Pooling(data=bn1_1, pool_type=\\\"max\\\", kernel=(3, 3), stride=(2, 2))\\n do1 = mx.sym.Dropout(data=pool1, p=0.25)\\n\\n # Block #2: second CONV => RELU => POOL layer set\\n conv2_1 = mx.sym.Convolution(data=do1, kernel=(5, 5), pad=(2, 2), num_filter=256)\\n act2_1 = mx.sym.LeakyReLU(data=conv2_1, act_type=\\\"elu\\\")\\n bn2_1 = mx.sym.BatchNorm(data=act2_1)\\n pool2 = mx.sym.Pooling(data=bn2_1, pool_type=\\\"max\\\", kernel=(3, 3), stride=(2, 2))\\n do2 = mx.sym.Dropout(data=pool2, p=0.25)\\n\\n # Block #3: (CONV => RELU) * 3 => POOL\\n conv3_1 = mx.sym.Convolution(data=do2, kernel=(3, 3), pad=(1, 1), num_filter=384)\\n act3_1 = mx.sym.LeakyReLU(data=conv3_1, act_type=\\\"elu\\\")\\n bn3_1 = mx.sym.BatchNorm(data=act3_1)\\n conv3_2 = mx.sym.Convolution(data=bn3_1, kernel=(3, 3), pad=(1, 1), num_filter=384)\\n act3_2 = mx.sym.LeakyReLU(data=conv3_2, act_type=\\\"elu\\\")\\n bn3_2 = mx.sym.BatchNorm(data=act3_2)\\n conv3_3 = mx.sym.Convolution(data=bn3_2, kernel=(3, 3), pad=(1, 1), num_filter=256)\\n act3_3 = mx.sym.LeakyReLU(data=conv3_3, act_type=\\\"elu\\\")\\n bn3_3 = mx.sym.BatchNorm(data=act3_3)\\n pool3 = mx.sym.Pooling(data=bn3_3, pool_type=\\\"max\\\", kernel=(3, 3), stride=(2, 2))\\n do3 = mx.sym.Dropout(data=pool3, p=0.25)\\n\\n # Block #4: first set of FC => RELU layers\\n flatten = mx.sym.Flatten(data=do3)\\n fc1 = mx.sym.FullyConnected(data=flatten, num_hidden=4096)\\n act4_1 = mx.sym.LeakyReLU(data=fc1, act_type=\\\"elu\\\")\\n bn4_1 = mx.sym.BatchNorm(data=act4_1)\\n do4 = mx.sym.Dropout(data=bn4_1, p=0.5)\\n\\n # Block #5: second set of FC => RELU layers\\n fc2 = mx.sym.FullyConnected(data=do4, num_hidden=4096)\\n act5_1 = mx.sym.LeakyReLU(data=fc2, act_type=\\\"elu\\\")\\n bn5_1 = mx.sym.BatchNorm(data=act5_1)\\n do5 = mx.sym.Dropout(data=bn5_1, p=0.5)\\n\\n # softmax classifier\\n fc3 = mx.sym.FullyConnected(data=do5, num_hidden=classes)\\n model = mx.sym.SoftmaxOutput(data=fc3, name=\\\"softmax\\\")\\n\\n # return the network architecture\\n return model\",\n \"def generate_tiles(self):\\n if self.children:\\n for child in self.children:\\n child.generate_tiles()\\n print \\\"Generating tile for %s using child tiles\\\" % self.bbox\\n self.generate_tile_from_child_tiles()\\n else:\\n print \\\"Generating tile for %s using source data\\\" % self.bbox\\n self.generate_tile_from_source()\",\n \"def drawMatrix(self,screen,pos):\\n bp = pos # base position bp\\n namesurface = myfont.render(self.parentname, False, self.parentcolour)\\n screen.blit(namesurface,(bp[0]-50,bp[1] -60),) \\n tempOffset = namesurface.get_width()\\n namesurface = myfont.render(self.name, False, self.colour)\\n screen.blit(namesurface,(bp[0]-40 ,bp[1]-30),) \\n size = 10\\n separationx = 12\\n separationy = 20\\n # Cycle through array of inputs\\n for i in range(self.dimensions[0]):\\n # Create red - green colour based on array\\n temp_colour = (int((1-self.scan[i])*240),int(self.scan[i]*240),0)\\n # Draw square that is slightly offset of previous square\\n pygame.draw.rect(screen,temp_colour ,(bp[0] - separationx *int(i / len(self.inputdistance)),\\n bp[1] - separationx*(i%len(self.inputdistance)) + 3*separationx,size,size))\\n # Calculate intermediate decision array\\n temp_vector = self.scan \\n # Repeat\\n for j, bs in enumerate(self.bias):\\n temp_vector = np.add(temp_vector.dot(self.weights[j]), bs)\\n for i in range(temp_vector.shape[0]):\\n temp_colour = (int(max(min((1-temp_vector[i])*240,240),0)),int(max(min(temp_vector[i]*240,240),0)),0)\\n pygame.draw.rect(screen,temp_colour ,(bp[0] + (j+1)*separationy,bp[1] + separationx*i,size,size))\",\n \"def _make_random_matrix(self, n_components, n_features):\",\n \"def _build_matrix(self, image):\\n offset_generator = self._iter_images_rects()\\n count = 1\\n for src_image in self._iter_images():\\n pos_x, pos_y, max_w, max_h = next(offset_generator)\\n src_image, width, height = self._image_resize_keep_ratio(src_image, max_w, max_h, self._crop)\\n # Adjust position to have identical margin between borders and images\\n if len(self._images) < 4:\\n pos_x, pos_y = pos_x + (max_w - width) // 2, pos_y + (max_h - height) // 2\\n elif count == 1:\\n pos_x, pos_y = pos_x + (max_w - width) * 2 // 3, pos_y + (max_h - height) * 2 // 3\\n elif count == 2:\\n pos_x, pos_y = pos_x + (max_w - width) // 3, pos_y + (max_h - height) * 2 // 3\\n elif count == 3:\\n pos_x, pos_y = pos_x + (max_w - width) * 2 // 3, pos_y + (max_h - height) // 3\\n else:\\n pos_x, pos_y = pos_x + (max_w - width) // 3, pos_y + (max_h - height) // 3\\n\\n self._image_paste(src_image, image, pos_x, pos_y)\\n count += 1\\n return image\",\n \"def compile(self):\\n self.train = self._make_train()\\n self.loss_test = self._make_loss_test()\\n self.predict = self._make_predict()\",\n \"def generate():\",\n \"def setUp(self):\\r\\n self.matrix = array(\\r\\n [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])\\r\\n self.cells = [(0, 1), (1, 3)]\\r\\n self.cells2 = [(0, 2), (2, 3)]\",\n \"def generate(self):\",\n \"def gen_matrix(e):\\n\\tif e < 1:\\n\\t\\treturn None\\n\\tm_list = [[[1, 2], [3, 0]]]\\n\\t_b = m_list[0]\\n\\tfor n in xrange(1, e):\\n\\t\\tm = m_list[n - 1]\\n\\t\\tm_list.append(\\n\\t\\t\\t[\\n\\t\\t\\t\\t[4 * i + _b[0][0] for i in m[0]] + [4 * i + _b[0][1] for i in m[0]],\\n\\t\\t\\t\\t[4 * i + _b[0][0] for i in m[1]] + [4 * i + _b[0][1] for i in m[1]],\\n\\t\\t\\t\\t[4 * i + _b[1][0] for i in m[0]] + [4 * i + _b[1][1] for i in m[0]],\\n\\t\\t\\t\\t[4 * i + _b[1][0] for i in m[1]] + [4 * i + _b[1][1] for i in m[1]],\\n\\t\\t\\t]\\n\\t\\t)\\n\\treturn m_list\",\n \"def _initializeMatrices(self):\\n K = self.K \\n # Initialize Initia\\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\\n rand_initial_prob = list(rand_initial_prob[0,:])\\n for i in range(K): \\n self.state_initial_prob[i+1] = rand_initial_prob[i]\\n\\n # Initialize the transition MAtrix !\\n for i in range(K):\\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\\n rand_initial_prob = list(rand_initial_prob[0,:]) \\n\\n for j in range(K):\\n self.state_transition_mat[(j+1,i+1)] = rand_initial_prob[j]\\n\\n\\n # Initialize the symbol distribution Parameters ui and si (Assuming a numeric outputs ! Modelled using a gaussian ! withmean ui and std si)\\n init_mean = np.mean(self.data_matrix)\\n init_std = np.std(self.data_matrix) \\n \\n for i in range(K):\\n random_mean = gauss(init_mean,30)\\n random_std = gauss(init_std,30)\\n self.state_symbol_prob[i+1] = {'mean':random_mean, 'std' : random_std}\",\n \"def create_output_matrix_files(self, year, max_zone_id):\\r\\n from opus_emme2.travel_model_output import TravelModelOutput\\r\\n tm_output = TravelModelOutput(self.emme_cmd)\\r\\n year_config = self.config['travel_model_configuration'][year]\\r\\n for x in 1,2,3:\\r\\n if \\\"bank%i\\\" % x in year_config['matrix_variable_map']:\\r\\n bank_dir = self.get_emme2_dir(year, \\\"bank%i\\\" % x)\\r\\n for matrix_name in year_config['matrix_variable_map'][\\\"bank%i\\\" % x].keys():\\r\\n tm_output._get_matrix_into_data_file(matrix_name, max_zone_id, bank_dir, \\\"%s_one_matrix.txt\\\" % matrix_name)\",\n \"def build_layers(self):\\n raise NotImplementedError\",\n \"def make_input_map(self) :\\n\\n self.input_map = \\\"\\\"\\n stencil = self.core.stencil\\n pattern = self.core.pattern\\n reflect = len(pattern)+1 # reflector id, last material\\n N = self.dimension\\n coremap = np.zeros((N+2,N+2), dtype='i')\\n \\n # reflections and vacuum\\n coremap[0, 1:N+1] = -1 \\n coremap[1:N+1, 0] = -1\\n coremap[N+1, 1:N+1] = -2\\n coremap[1:N+1, N+1] = -2\\n \\n fuelindex = 0\\n \\n for i in range(1, N+1) :\\n for j in range(1, N+1) :\\n if j == 1 and i > 1 :\\n pass\\n else :\\n if stencil[i-1, j-1] > 0 : # a fuel\\n coremap[i, j] = pattern[fuelindex]+1\\n fuelindex += 1\\n elif stencil[i-1, j-1] == 0 : # a reflector\\n coremap[i, j] = reflect\\n else : # a void\\n pass \\n # Copy elements such that rotational symmetry is enforced. \\n for j in range(2, N+1) :\\n coremap[j, 1] = coremap[1, j]\\n for i in range(0, N+2) :\\n for j in range(0, N+2) :\\n self.input_map +='%4i' % (coremap[i, j])\\n self.input_map += '\\\\n'\",\n \"def _init_model(self):\\n self.A_inv = np.zeros(shape=(self.numUsers, self.d, self.d))\\n self.b = np.zeros(shape=(self.numUsers, self.d))\\n self.w = np.zeros(shape=(self.numUsers, self.d))\\n for i, mat in enumerate(self.A_inv):\\n self.A_inv[i] = np.eye(self.d)\",\n \"def build(self):\\n\\n self.W_AA = self.init([self.n_atom_input_feat, self.n_hidden_AA])\\n self.b_AA = model_ops.zeros(shape=[\\n self.n_hidden_AA,\\n ])\\n\\n self.W_PA = self.init([self.n_pair_input_feat, self.n_hidden_PA])\\n self.b_PA = model_ops.zeros(shape=[\\n self.n_hidden_PA,\\n ])\\n\\n self.W_A = self.init([self.n_hidden_A, self.n_atom_output_feat])\\n self.b_A = model_ops.zeros(shape=[\\n self.n_atom_output_feat,\\n ])\\n\\n self.trainable_weights = [\\n self.W_AA, self.b_AA, self.W_PA, self.b_PA, self.W_A, self.b_A\\n ]\\n if self.update_pair:\\n self.W_AP = self.init([self.n_atom_input_feat * 2, self.n_hidden_AP])\\n self.b_AP = model_ops.zeros(shape=[\\n self.n_hidden_AP,\\n ])\\n\\n self.W_PP = self.init([self.n_pair_input_feat, self.n_hidden_PP])\\n self.b_PP = model_ops.zeros(shape=[\\n self.n_hidden_PP,\\n ])\\n\\n self.W_P = self.init([self.n_hidden_P, self.n_pair_output_feat])\\n self.b_P = model_ops.zeros(shape=[\\n self.n_pair_output_feat,\\n ])\\n\\n self.trainable_weights.extend(\\n [self.W_AP, self.b_AP, self.W_PP, self.b_PP, self.W_P, self.b_P])\",\n \"def _build(self):\\n with tf.variable_scope (self.name + '_architecutre') as scope:\\n images_square = unflatten_layer ( self.images )\\n visualize_images(images_square)\\n\\n # Conv Layer 1\\n conv1_out, params = conv_2d_layer ( input = images_square,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n name = 'enc_conv_1',\\n visualize = True )\\n process_params(params, name = self.name)\\n e1_params = params\\n pool1_out = max_pool_2d_layer ( input = conv1_out, name = 'enc_pool_1')\\n # lrn1_out = local_response_normalization_layer (pool1_out, name = 'lrn_1' )\\n\\n # Conv Layer 2\\n conv2_out, params = conv_2d_layer ( input = pool1_out,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n name = 'enc_conv_2' )\\n process_params(params, name = self.name)\\n e2_params = params\\n pool2_out = max_pool_2d_layer ( input = conv2_out, name = 'enc_pool_2')\\n # lrn2_out = local_response_normalization_layer (pool2_out, name = 'lrn_2' )\\n\\n flattened = flatten_layer(pool2_out)\\n\\n # Dropout Layer 1 \\n flattened_dropout = dropout_layer ( input = flattened,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_1') \\n\\n # Dot Product Layer 1\\n fc1_out, params = dot_product_layer ( input = flattened_dropout,\\n neurons = HIDDEN_1,\\n name = 'enc_dot_1')\\n process_params(params, name = self.name)\\n e3_params = params \\n\\n # Dropout Layer 2 \\n fc1_out_dropout = dropout_layer ( input = fc1_out,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_2')\\n # Dot Product Layer 2\\n fc2_out, params = dot_product_layer ( input = fc1_out_dropout, \\n neurons = HIDDEN_2,\\n name = 'enc_dot_2')\\n process_params(params, name = self.name)\\n e4_params = params \\n\\n # Dropout Layer 3 \\n fc2_out_dropout = dropout_layer ( input = fc2_out,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_3')\\n \\n # Dot Product Layer 2\\n self.codeword, params = dot_product_layer ( input = fc2_out_dropout, \\n neurons = CODEWORD_LENGTH,\\n activation = CODE_ACTIVATION,\\n name = 'enc_dot_2')\\n process_params(params, name = self.name)\\n process_codeword_normalization_regularizer(self.codeword, \\n coeff = AUTOENCODER_CODEWORD_COEFF,\\n name = self.name)\\n e5_params = params \\n # tf.summary.histogram('codewords', self.codeword)\\n # self.hash = threshold_layer ( input = self.codeword,\\n # name = 'hash')\\n # process_hash_regularizer(self.codeword, coeff = AUTOENCODER_HASH_COEFF,\\n # name = self.name)\\n\\n # Decoder ... \\n decoder_1_out, params = dot_product_layer ( input = self.codeword, \\n neurons = HIDDEN_2,\\n params = [tf.transpose(e5_params[0]), None],\\n name = 'decoder_dot_1')\\n d1_params = params\\n process_params([params[1]], name = self.name)\\n \\n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\\n prob = self.dropout_prob,\\n name = 'dec_dropout_1')\\n\\n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \\n neurons = HIDDEN_1,\\n params = [tf.transpose(e4_params[0]), None],\\n name = 'decoder_dot_2')\\n d2_params = params\\n process_params([params[1]], name = self.name)\\n \\n # dropout 2\\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\\n prob = self.dropout_prob,\\n name = 'dec_dropout_2')\\n\\n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \\n neurons = 1250,\\n params = [tf.transpose(e3_params[0]), None],\\n name = 'decoder_dot_3')\\n d3_params = params\\n process_params([params[1]], name = self.name)\\n\\n # DeConv Layer 1\\n # The output shapes need to be changed according to architecture.\\n\\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N )\\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), name = 'dec_upsampling_1')\\n\\n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\\n neurons = CONV_1_N,\\n filter_size = CONV_2_FILT,\\n output_shape = (12,12),\\n # n_outs = MINI_BATCH_SIZE,\\n stride = (1,1,1,1), \\n params = [e2_params[0], None], \\n name = 'dec_deconv_1' )\\n\\n process_params([params[1]], name = self.name)\\n d4_params = params\\n\\n # DeConv Layer 2\\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), name = 'dec_upsampling_2')\\n decoded_images_square, params = deconv_2d_layer ( input = upsample_2,\\n neurons = 1,\\n filter_size = CONV_1_FILT,\\n stride = (1,1,1,1),\\n output_shape = (28,28),\\n # n_outs = MINI_BATCH_SIZE, \\n params = [e1_params[0], None], \\n activation = 'tanh', \\n name = 'dec_deconv_2' )\\n \\n process_params([params[1]], name = self.name)\\n d5_params = params \\n \\n self.decoded = flatten_layer (decoded_images_square, in_shp = [-1, 28, 28, 1])\\n visualize_images(decoded_images_square, name = 'decoded')\\n # This is because transpose don't initialize.\\n self.params = [ [e5_params[0], d1_params[1] ],\\n [e4_params[0], d2_params[1] ],\\n [e3_params[0], d3_params[1] ],\\n [e2_params[0], d4_params[1] ],\\n [e1_params[0], d5_params[1] ] ]\\n\\n with tf.variable_scope (self.name + '_objectives') as scope: \\n with tf.variable_scope( self.name + '_decoder_error') as scope:\\n reconstruction_error = rmse(self.images, self.decoded) \\n tf.add_to_collection( self.name + '_objectives', reconstruction_error ) \\n tf.summary.scalar('reconstruction_error', reconstruction_error)\\n\\n self._cook_optimizer( \\n lr = AUTOENCODER_LR, \\n optimizer = AUTOENCODER_OPTIMIZER,\\n l1_coeff = AUTOENCODER_L1_COEFF,\\n l2_coeff = AUTOENCODER_WEIGHT_DECAY_COEFF)\",\n \"def _init_layers(self) -> None:\\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\\n self.cross_attn = MultiheadAttention(**self.cross_attn_cfg)\\n self.embed_dims = self.self_attn.embed_dims\\n self.ffn = FFN(**self.ffn_cfg)\\n norms_list = [\\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\\n for _ in range(3)\\n ]\\n self.norms = ModuleList(norms_list)\",\n \"def build(self):\\n\\n self.W = self.init([self.n_atom_input_feat, self.n_output])\\n self.b = model_ops.zeros(shape=[\\n self.n_output,\\n ])\\n\\n self.trainable_weights = self.W + self.b\",\n \"def generate_mos(laygen, objectname_pfix, placement_grid, routing_grid_m1m2, devname_mos_boundary, devname_mos_body,\\n devname_mos_dmy, m=1, m_dmy=0, origin=np.array([0,0])):\\n pg = placement_grid\\n rg12 = routing_grid_m1m2\\n pfix = objectname_pfix\\n\\n # placement\\n imbl0 = laygen.relplace(name=\\\"I\\\" + pfix + 'BL0', templatename=devname_mos_boundary, gridname=pg, xy=origin)\\n refi=imbl0\\n if not m_dmy==0:\\n imdmyl0 = laygen.relplace(name=\\\"I\\\" + pfix + 'DMYL0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\\n refi=imdmyl0\\n else:\\n imdmyl0 = None\\n im0 = laygen.relplace(name=\\\"I\\\" + pfix + '0', templatename=devname_mos_body, gridname=pg, refobj=refi, shape=[m, 1])\\n refi=im0\\n if not m_dmy==0:\\n imdmyr0 = laygen.relplace(name=\\\"I\\\" + pfix + 'DMYR0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\\n refi=imdmyr0\\n else:\\n imdmyr0 = None\\n imbr0 = laygen.relplace(name=\\\"I\\\" + pfix + 'BR0', templatename=devname_mos_boundary, gridname=pg, refobj=imdmyr0)\\n md=im0.elements[:, 0]\\n #route\\n #gate\\n rg0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['G0'], refobj1=md[-1].pins['G0'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['G0'], gridname=rg12)\\n #drain\\n rdl0=laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=md[0].pins['D0'], refobj1=md[-1].pins['D0'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 1], refobj=_md.pins['D0'], gridname=rg12)\\n #source\\n rs0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['S0'], refobj1=md[-1].pins['S1'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['S0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=md[-1].pins['S1'], gridname=rg12)\\n #dmy\\n if m_dmy>=2:\\n mdmyl=imdmyl0.elements[:, 0]\\n mdmyr=imdmyr0.elements[:, 0]\\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyl[0].pins['D0'], refobj1=mdmyl[-1].pins['D0'])\\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyr[0].pins['D0'], refobj1=mdmyr[-1].pins['D0'])\\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyl[0].pins['S0'], refobj1=mdmyl[-1].pins['S1'])\\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyr[0].pins['S0'], refobj1=mdmyr[-1].pins['S1'])\\n for _mdmyl in mdmyl:\\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyl.pins['D0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyl.pins['S0'], gridname=rg12)\\n for _mdmyr in mdmyr:\\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyr.pins['D0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyr.pins['S1'], gridname=rg12)\\n return [imbl0, imdmyl0, im0, imdmyr0, imbr0]\",\n \"def generate_features(self):\\n content_input = self.content_image * 255\\n style_input = self.style_image * 255\\n preprocessed_content = tf.keras.applications.vgg19.preprocess_input(\\n content_input)\\n preprocessed_style = tf.keras.applications.vgg19.preprocess_input(\\n style_input)\\n outputs_content = self.model(preprocessed_content)\\n outputs_style = self.model(preprocessed_style)\\n\\n num_style_layers = tf.size(self.style_layers)\\n style_outputs, content_outputs = (\\n outputs_style[:num_style_layers],\\n outputs_content[num_style_layers:])\\n\\n style_outputs = [self.gram_matrix(\\n style_output)for style_output in style_outputs]\\n self.gram_style_features = style_outputs\\n self.content_feature = content_outputs\",\n \"def initialize_matrices(self):\\n assert self._training_dataset and self._valid_dataset\\n # inject prior knowledge about transition and emission\\n self._state_prior = torch.zeros(self._config.d_hidden, device=self._config.device) + 1e-2\\n self._state_prior[0] += 1 - self._state_prior.sum()\\n\\n intg_obs = list(map(np.array, self._training_dataset.obs + self._valid_dataset.obs))\\n self._trans_mat = torch.tensor(initialise_transmat(\\n observations=intg_obs, label_set=self._config.bio_label_types)[0], dtype=torch.float)\\n self._emiss_mat = torch.tensor(initialise_emissions(\\n observations=intg_obs, label_set=self._config.bio_label_types,\\n sources=self._config.sources, src_priors=self._config.src_priors\\n )[0], dtype=torch.float)\\n return self\",\n \"def _build(self, z, targets= None, input_params = None):\\n with tf.variable_scope (self.name + '_architecture') as scope:\\n with tf.variable_scope ( 'generator') as scope:\\n self.z = z\\n self.targets =targets\\n\\n # Dot Product Layer 1\\n par = input_params[0]\\n process_params(par, name = self.name) \\n par[0] = tf.transpose(par[0]) \\n # Decoder ... \\n decoder_1_out, params = dot_product_layer ( input = self.z, \\n neurons = HIDDEN_2,\\n params = par,\\n name = 'gen_decoder_dot_1')\\n g1_params = params\\n \\n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\\n prob = self.dropout_prob,\\n name = 'gen_dropout_1')\\n\\n # Dot Product Layer 2 \\n par = input_params[1]\\n process_params(par, name = self.name) \\n par[0] = tf.transpose(par[0]) \\n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \\n neurons = HIDDEN_1,\\n params = par,\\n name = 'gen_decoder_dot_2')\\n g2_params = params\\n\\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\\n prob = self.dropout_prob,\\n name = 'gen_dropout_2')\\n\\n # Dot Product Layer 3 \\n par = input_params[2]\\n process_params(par, name = self.name) \\n par[0] = tf.transpose(par[0]) \\n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \\n neurons = 1250,\\n params = par,\\n name = 'gen_decoder_dot_0')\\n g3_params = params\\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N,\\n name = 'gen_unflatten' )\\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), \\n name = 'gen_upsampling_1')\\n\\n # Convolution layer 1\\n par = input_params[3]\\n process_params(par, name = self.name) \\n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\\n neurons = CONV_1_N,\\n filter_size = CONV_2_FILT,\\n output_shape = (12,12),\\n params = par, \\n name = 'deconv_1' )\\n\\n g4_params = params\\n\\n # DeConv Layer 2\\n par = input_params[4]\\n process_params(par, name = self.name)\\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), \\n name = 'gen_upsampling_2')\\n generated_images_square, params = deconv_2d_layer ( \\n input = upsample_2,\\n neurons = 1,\\n filter_size = CONV_1_FILT,\\n stride = (1,1,1,1),\\n output_shape = (28,28),\\n params = par, \\n activation = 'tanh', \\n name = 'conv_2' )\\n \\n g5_params = params\\n self.generation = flatten_layer (generated_images_square, in_shp = [-1, 28, 28, 1])\\n visualize_images(generated_images_square, name = 'generated_images')\\n self.params = [g1_params, g2_params, g3_params, g4_params, g5_params]\",\n \"def _build_forward_graph(self):\\n\\n print('[*] Building a Neural Turing Machine.')\\n\\n self._initalize_state()\\n\\n # present start token\\n controller_out = self.controller.emit_feature_vector(self.start_token, self.r_t[0], reuse=None)\\n self._read_write(controller_out, reuse=None)\\n\\n # present inputs\\n print('Input chain: ')\\n for t in range(0, self.sequence_length):\\n print_progress(float(t + 1) / self.sequence_length)\\n\\n controller_out = self.controller.emit_feature_vector(self.inputs[t], self.r_t[-1], reuse=True)\\n self._read_write(controller_out, reuse=True)\\n\\n # present end token\\n controller_out = self.controller.emit_feature_vector(self.end_token, self.r_t[-1], reuse=True)\\n self._read_write(controller_out, reuse=True)\\n\\n # present outputs\\n print('Output chain: ')\\n for t in range(0, self.sequence_length):\\n print_progress(float(t + 1) / self.sequence_length)\\n\\n controller_out = self.controller.emit_feature_vector(self.zeros, self.r_t[-1], reuse=True)\\n self._read_write(controller_out, reuse=True)\\n\\n reuse = None if t == 0 else True\\n self.outputs.append(self._decode_read_vector(self.r_t[-1], reuse=reuse))\\n print('Done.')\",\n \"def _build_all_models(self):\\r\\n self.output_tensors = {}\\r\\n self.loss_terms = {}\\r\\n self.metrics = {}\\r\\n\\r\\n def _build_datasource_summaries(data_sources, mode):\\r\\n \\\"\\\"\\\"Register summary operations for input data from given data sources.\\\"\\\"\\\"\\r\\n with tf.variable_scope('%s_data' % mode):\\r\\n for data_source_name, data_source in data_sources.items():\\r\\n tensors = data_source.output_tensors\\r\\n for key, tensor in tensors.items():\\r\\n summary_name = '%s/%s' % (data_source_name, key)\\r\\n shape = tensor.shape.as_list()\\r\\n num_dims = len(shape)\\r\\n if num_dims == 4: # Image data\\r\\n if shape[1] == 1 or shape[1] == 3:\\r\\n self.summary.image(summary_name, tensor,\\r\\n data_format='channels_first')\\r\\n elif shape[3] == 1 or shape[3] == 3:\\r\\n self.summary.image(summary_name, tensor,\\r\\n data_format='channels_last')\\r\\n # TODO: fix issue with no summary otherwise\\r\\n elif num_dims == 2:\\r\\n self.summary.histogram(summary_name, tensor)\\r\\n else:\\r\\n logger.debug('I do not know how to create a summary for %s (%s)' %\\r\\n (summary_name, tensor.shape.as_list()))\\r\\n\\r\\n def _build_train_or_test(mode):\\r\\n data_sources = self._train_data if mode == 'train' else self._test_data\\r\\n\\r\\n # Build model\\r\\n output_tensors, loss_terms, metrics = self.build_model(data_sources, mode=mode)\\r\\n\\r\\n # Record important tensors\\r\\n self.output_tensors[mode] = output_tensors\\r\\n self.loss_terms[mode] = loss_terms\\r\\n self.metrics[mode] = metrics\\r\\n\\r\\n # Create summaries for scalars\\r\\n if mode == 'train':\\r\\n for name, loss_term in loss_terms.items():\\r\\n self.summary.scalar('loss/%s/%s' % (mode, name), loss_term)\\r\\n for name, metric in metrics.items():\\r\\n self.summary.scalar('metric/%s/%s' % (mode, name), metric)\\r\\n\\r\\n # Build the main model\\r\\n if len(self._train_data) > 0:\\r\\n _build_datasource_summaries(self._train_data, mode='train')\\r\\n _build_train_or_test(mode='train')\\r\\n logger.info('Built model.')\\r\\n\\r\\n # Print no. of parameters and lops\\r\\n flops = tf.profiler.profile(\\r\\n options=tf.profiler.ProfileOptionBuilder(\\r\\n tf.profiler.ProfileOptionBuilder.float_operation()\\r\\n ).with_empty_output().build())\\r\\n logger.info('------------------------------')\\r\\n logger.info(' Approximate Model Statistics ')\\r\\n logger.info('------------------------------')\\r\\n logger.info('FLOPS per input: {:,}'.format(flops.total_float_ops / self._batch_size))\\r\\n logger.info(\\r\\n 'Trainable Parameters: {:,}'.format(\\r\\n np.sum([np.prod(v.shape.as_list()) for v in tf.trainable_variables()])\\r\\n )\\r\\n )\\r\\n logger.info('------------------------------')\\r\\n\\r\\n # If there are any test data streams, build same model with different scope\\r\\n # Trainable parameters will be copied at test time\\r\\n if len(self._test_data) > 0:\\r\\n _build_datasource_summaries(self._test_data, mode='test')\\r\\n with tf.variable_scope('test'):\\r\\n _build_train_or_test(mode='test')\\r\\n logger.info('Built model for live testing.')\\r\\n\\r\\n if self._enable_live_testing:\\r\\n self._tester._post_model_build() # Create copy ops to be run before every test run\\r\",\n \"def construct(self):\\n self.input_size = self.numplanes * self.boardsize**2\\n \\n if self.hidden:\\n layers = [\\n torch.nn.Linear(self.input_size, self.hidden), \\n torch.nn.ReLU(),\\n torch.nn.Linear(self.hidden, self.boardsize**2)\\n ]\\n else:\\n layers = [torch.nn.Linear(self.input_size, self.boardsize**2)]\\n\\n self.layers = torch.nn.ModuleList(layers)\\n self.optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)\\n logging.info(\\\"Model initialized: %s\\\", self)\",\n \"def main():\\n g = CommanderGame([4, 3], 3)\\n g.fit_army_orders()\\n g.fit_game_matrix()\\n g.show_submatrixes([\\n [[4, 0, 0]],\\n [[2, 1, 0], [1, 1, 1]],\\n ])\\n print(f'Full game matrix: \\\\n{g.game_matrix_}')\",\n \"def process(self, mat):\",\n \"def main():\\n num_schedules = 150\\n trainer = AutoEncoderTrain(num_schedules)\\n trainer.train()\\n trainer.compute_mean()\\n trainer.create_iterables()\\n\\n trainer.round_each_encoding_and_create_array()\\n trainer.populate_a_matrix_per_schedule()\\n trainer.save_matrixes()\",\n \"def matrix_generation(self, matrix_size, generate_to):\\n matrix_A = np.random.randint(generate_to, size=(matrix_size, matrix_size))\\n matrix_B = np.random.randint(generate_to, size=(matrix_size, matrix_size))\\n # print(matrix_A)\\n # print(matrix_B)\\n # print(np.matmul(matrix_A, matrix_B))\\n matrices = (matrix_A, matrix_B)\\n return matrices\",\n \"def compile(self):\\n m, n = self.input_shape[1], self.input_shape[2]\\n\\n inp = Input(shape=self.input_shape, traces=True)\\n self.add_layer(inp, \\\"DoG\\\")\\n\\n s1 = LIFNodes(shape=(18, m, n), traces=True)\\n self.add_layer(s1, \\\"conv_1\\\")\\n c1 = LIFNodes(shape=(18, m // 2, n // 2), traces=True)\\n self.add_layer(c1, \\\"pool_1\\\")\\n\\n s2 = LIFNodes(shape=(24, m // 2, n // 2), traces=True)\\n self.add_layer(s2, \\\"conv_2\\\")\\n c2 = LIFNodes(shape=(24, m // 4, n // 4), traces=True)\\n self.add_layer(c2, \\\"pool_2\\\")\\n\\n s3 = LIFNodes(shape=(32, m // 4, n // 4), traces=True)\\n self.add_layer(s3, \\\"conv_3\\\")\\n f = LIFNodes(shape=(32, 1), traces=True)\\n self.add_layer(f, \\\"global_pool\\\")\\n\\n conv1 = Conv2dConnection(inp, s1, 5, padding=2, weight_decay=0.01,\\n nu=0.01, update_rule=PostPre, decay=0.5)\\n self.add_connection(conv1, \\\"DoG\\\", \\\"conv_1\\\")\\n pool1 = MaxPool2dConnection(s1, c1, 2, 2, decay=0.5)\\n self.add_connection(pool1, \\\"conv_1\\\", \\\"pool_1\\\")\\n\\n conv2 = Conv2dConnection(c1, s2, 3, padding=1, weight_decay=0.01,\\n nu=0.01, update_rule=PostPre, decay=0.5)\\n self.add_connection(conv2, \\\"pool_1\\\", \\\"conv_2\\\")\\n pool2 = MaxPool2dConnection(s2, c2, 2, 2, decay=0.5)\\n self.add_connection(pool2, \\\"conv_2\\\", \\\"pool_2\\\")\\n\\n conv3 = Conv2dConnection(c2, s3, 3, padding=1, weight_decay=0.01,\\n nu=0.01, update_rule=PostPre, decay=0.5)\\n self.add_connection(conv3, \\\"pool_2\\\", \\\"conv_3\\\")\\n global_pool = MaxPool2dConnection(s3, f, (m // 4, n // 4), decay=0.5)\\n self.add_connection(global_pool, \\\"conv_3\\\", \\\"global_pool\\\")\\n\\n monitor = NetworkMonitor(self, layers=[\\\"DoG\\\", \\\"conv_1\\\", \\\"pool_1\\\",\\n \\\"conv_2\\\", \\\"pool_2\\\",\\n \\\"conv_3\\\", \\\"global_pool\\\"],\\n connections=[(\\\"DoG\\\", \\\"conv_1\\\"),\\n (\\\"pool_1\\\", \\\"conv_2\\\"),\\n (\\\"pool_2\\\", \\\"conv_3\\\")],\\n state_vars=[\\\"w\\\", \\\"s\\\"])\\n self.add_monitor(monitor, \\\"network_monitor\\\")\\n\\n return self\",\n \"def build_model(self):\\n import tensorflow as tf\\n \\n y = tf.nn.relu(tf.matmul(self.variables[\\\"input_observation\\\"], self.variables[\\\"W1\\\"]) + \\n self.variables[\\\"b1\\\"], name=\\\"y1\\\")\\n \\n for i in range(self.n_hidden-1):\\n y = tf.nn.relu(tf.matmul(y, self.variables[\\\"W\\\"+str(i+2)]) + \\n self.variables[\\\"b\\\"+str(i+2)], name=\\\"y\\\"+str(i+2))\\n \\n self.variables[\\\"y\\\"] = [tf.matmul(y, self.variables[\\\"Wo_0\\\"]) + self.variables[\\\"bo_0\\\"]]\\n for i in range(1, len(self.output_size)):\\n self.variables[\\\"y\\\"] += [tf.matmul(y, self.variables[\\\"Wo_%s\\\"%i]) + self.variables[\\\"bo_%s\\\"%i]]\",\n \"def _export_model(self):\\n graph = ComputeGraph.from_onnx(self.onnx_model.graph)\\n\\n print(\\\"Running constant propagation\\\")\\n constant_states = constant_propagation(graph)\\n\\n self._remove_constants(graph, constant_states)\\n self._remove_nops(graph, constant_states)\\n\\n # Add shape information from constant propagation:\\n for var, res in constant_states.items():\\n if var in graph.shape_dict:\\n shape = graph.shape_dict[var]\\n if res.shape != shape:\\n print(\\\"Warning: Shapes do not match: \\\", var, res.shape, shape)\\n if res.shape is not None:\\n print(\\\"Replacing shape {} with {}\\\".format(shape, res.shape))\\n graph.shape_dict[var] = res.shape\\n elif res.shape is not None:\\n graph.shape_dict[var] = res.shape\\n\\n print(\\\"Inference graph:\\\")\\n for node in graph.nodes:\\n inputs = node.inputs\\n input_shapes = (str(graph.shape_dict[i]) for i in node.inputs if i in graph.shape_dict)\\n outputs = node.outputs\\n output_shapes = (str(graph.shape_dict[o]) for o in node.outputs if o in graph.shape_dict)\\n print(\\\"{:<24} {:<20} {:<30} {:<30} {:<20} {:<30}\\\".format(node.name,\\n node.op_type,\\n \\\",\\\".join(inputs),\\n \\\",\\\".join(input_shapes),\\n \\\",\\\".join(outputs),\\n \\\",\\\".join(output_shapes)))\\n\\n memory_manager = MemoryManager()\\n\\n self._generate_weights_file(graph)\\n\\n self.dummy_input = generate_dummy_main(graph)\\n\\n self.reference_input = generate_reference_main(graph)\\n\\n self._generate_network_initialization(graph, memory_manager)\\n\\n self._generate_network_cleanup(graph, memory_manager)\\n\\n implementations = self._select_implementations(graph, memory_manager)\\n schedule = self._get_schedule(graph, implementations)\\n # self._print_live_ranges(schedule)\\n\\n input_names = [\\\"input_\\\"+name.replace('.', '_').replace(':', '_').replace('/', '_')\\n for name, type, shape in graph.inputs]\\n output_names = [\\\"output_\\\"+name.replace('.', '_').replace(':', '_').replace('/', '_')\\n for name, type, shape in graph.outputs]\\n\\n \\\"\\\"\\\"Currently we only allow single input (no batch processing) to the CNN, but this may be multi-channel input\\\"\\\"\\\"\\n inputs = graph.inputs\\n if len(inputs) > 1:\\n print(\\\"ERROR: Multiple inputs not supported!\\\")\\n exit(1)\\n else:\\n input_shape = graph.shape_dict[inputs[0].name]\\n print(\\\"Input shape: {}\\\".format(input_shape))\\n\\n if len(input_shape) == 4:\\n if input_shape[0] != 1:\\n print(\\\"ERROR: Inference for batch_size > 1 currently not supported!\\\")\\n exit(1)\\n\\n input_defs = [\\\"pico_cnn::naive::Tensor *\\\"+n for n in input_names]\\n\\n elif len(input_shape) == 3:\\n if input_shape[0] != 1:\\n print(\\\"ERROR: Inference for batch_size > 1 currently not supported!\\\")\\n exit(1)\\n\\n input_defs = [\\\"pico_cnn::naive::Tensor *\\\"+n for n in input_names]\\n\\n elif len(input_shape) == 2:\\n print(\\\"Input is one-dimensional (batch_size = 1 and num_input_channels = 1)\\\")\\n input_defs = [\\\"pico_cnn::naive::Tensor *\\\"+n for n in input_names]\\n\\n outputs = graph.outputs\\n if len(outputs) > 1:\\n print(\\\"ERROR: Multiple outputs not supported\\\")\\n exit(1)\\n else:\\n output_shape = graph.shape_dict[outputs[0].name]\\n print(\\\"Output shape: {}\\\".format(output_shape))\\n\\n if len(output_shape) == 2:\\n print(\\\"Output is one-dimensional (batch_size = 1 and num_input_channels = 1)\\\")\\n output_defs = [\\\"pico_cnn::naive::Tensor *\\\" + n for n in output_names]\\n elif len(output_shape) == 3:\\n print(\\\"ERROR: Unknown output shape of network: {}\\\".format(output_shape))\\n exit(1)\\n elif len(output_shape) == 4:\\n print(\\\"ERROR: Multi-dimensional output is currently not supported.\\\")\\n exit(1)\\n\\n network_def = \\\"void Network::run(\\\" + \\\", \\\".join(input_defs) + \\\", \\\" + \\\", \\\".join(output_defs) + \\\")\\\"\\n network_def_header = \\\"void run(\\\" + \\\", \\\".join(input_defs) + \\\", \\\" + \\\", \\\".join(output_defs) + \\\")\\\"\\n\\n layer_declaration_code = \\\"\\\"\\n layer_allocation_code = \\\"\\\"\\n layer_execution_code = \\\"\\\"\\n layer_deletion_code = \\\"\\\"\\n\\n \\\"\\\"\\\"Iterate over all tasks in the schedule, put some debug info in the code and the pico-cnn implementation.\\\"\\\"\\\"\\n for task in schedule:\\n num, node, impl = task\\n layer_allocation_code += \\\" //Layer \\\" + str(num) + \\\" \\\" + node.name + \\\" \\\" + node.op_type + \\\"\\\\n\\\"\\n layer_allocation_code += \\\" //Attributes\\\\n\\\"\\n for key, val in node.attrs.items():\\n layer_allocation_code += \\\" // \\\" + str(key) + \\\": \\\" + str(val) + \\\"\\\\n\\\"\\n layer_allocation_code += \\\" //Parameters\\\\n\\\"\\n layer_allocation_code += \\\" //Inputs: \\\" + \\\",\\\".join(node.inputs) + \\\"\\\\n\\\"\\n layer_allocation_code += \\\" //Outputs: \\\" + \\\",\\\".join(node.outputs) + \\\"\\\\n\\\"\\n layer_allocation_code += \\\" //Shape:\\\\n\\\"\\n for i in node.inputs:\\n layer_allocation_code += \\\" // {}: {}\\\\n\\\".format(i, graph.get_shape(i))\\n for o in node.outputs:\\n layer_allocation_code += \\\" // {}: {}\\\\n\\\".format(o, graph.get_shape(o))\\n\\n if impl:\\n layer_declaration_code += impl.generate_declaration()\\n layer_declaration_code += \\\"\\\\n\\\"\\n\\n layer_allocation_code += impl.generate_allocation()\\n layer_allocation_code += \\\"\\\\n\\\"\\n\\n layer_execution_code += impl.generate_execution()\\n layer_execution_code += \\\"\\\\n\\\"\\n\\n layer_deletion_code += impl.generate_deletion()\\n layer_deletion_code += \\\"\\\\n\\\"\\n\\n else:\\n print(\\\"ERROR: Unsupported layer: {}! Aborting code generation.\\\".format(node.op_type))\\n return 1\\n\\n self.constructor_code += layer_allocation_code + \\\"\\\\n\\\"\\n self.destructor_code += layer_deletion_code + \\\"\\\\n\\\"\\n\\n # # TODO: What does this loop do?\\n # for id, buffer in memory_manager.buffers.items():\\n # if graph.is_tensor(id):\\n # continue\\n # if graph.is_input(id):\\n # continue\\n # if graph.is_output(id):\\n # continue\\n\\n network_code: Text = \\\"#include \\\\\\\"network.h\\\\\\\"\\\\n\\\\n\\\"\\n network_code += \\\"Network::Network() {\\\\n\\\\n\\\"\\n network_code += self.constructor_code + \\\"\\\\n\\\"\\n network_code += \\\"}\\\\n\\\\n\\\"\\n network_code += \\\"Network::~Network() {\\\\n\\\"\\n network_code += self.destructor_code + \\\"\\\\n\\\"\\n network_code += \\\"}\\\\n\\\\n\\\"\\n network_code += network_def+\\\"{\\\\n\\\"\\n network_code += layer_execution_code\\n\\n network_code += \\\"}\\\\n\\\\n\\\"\\n\\n network_header = \\\"#ifndef NETWORK_H\\\\n\\\"\\n network_header += \\\"#define NETWORK_H\\\\n\\\\n\\\"\\n network_header += \\\"#include \\\\\\\"pico-cnn/pico-cnn.h\\\\\\\"\\\\n\\\\n\\\"\\n network_header += \\\"class Network {\\\\n\\\"\\n network_header += \\\"public:\\\\n\\\"\\n network_header += \\\"Network();\\\\n\\\"\\n network_header += \\\"~Network();\\\\n\\\"\\n network_header += network_def_header + \\\"; \\\\n\\\\n\\\"\\n network_header += self.buffer_declaration + \\\"\\\\n\\\"\\n network_header += layer_declaration_code\\n network_header += \\\"};\\\\n\\\"\\n network_header += \\\"#endif //NETWORK_H\\\\n\\\"\\n\\n self.network_code = network_code\\n self.network_header = network_header\\n\\n \\\"\\\"\\\"\\n Create Makefile containing a target for the generated dummy input and a network specific one.\\n The code for the network specific input has to be written manually.\\n \\\"\\\"\\\"\\n # TODO: Does this need to be more sophisticated?\\n self.makefile = \\\"CC = g++\\\\n\\\"\\n self.makefile += \\\"CFLAGS = -std=c++11 -Wall -O2 -march=native -DINFO\\\\n\\\"\\n self.makefile += \\\"LDFLAGS = -L../../../pico-cnn\\\\n\\\"\\n self.makefile += \\\"LD_LIBS = -lpico-cnn -lm\\\\n\\\\n\\\"\\n self.makefile += \\\"# list of all generated .cpp files.\\\\n\\\"\\n self.makefile += \\\"NETWORK_LIST = network.cpp\\\"\\n self.makefile += \\\"\\\\n\\\\ndummy_input: dummy_input.cpp $(NETWORK_LIST) libpico-cnn.a\\\\n\\\\t\\\"\\n self.makefile += \\\"$(CC) dummy_input.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) $(LDFLAGS) $(LD_LIBS) -o dummy_input\\\"\\n self.makefile += \\\"\\\\n\\\\nreference_input: reference_input.cpp $(NETWORK_LIST) libpico-cnn.a\\\\n\\\\t\\\"\\n self.makefile += \\\"$(CC) reference_input.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) \\\" \\\\\\n \\\"$(LDFLAGS) $(LD_LIBS) -o reference_input\\\"\\n self.makefile += \\\"\\\\n\\\\n{}: {}.cpp $(NETWORK_LIST) libpico-cnn.a\\\\n\\\\t\\\".format(self.model_name, self.model_name)\\n self.makefile += \\\"$(CC) {}.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) \\\" \\\\\\n \\\"$(LDFLAGS) $(LD_LIBS) -o {}\\\".format(self.model_name, self.model_name)\\n self.makefile += \\\"\\\\n\\\\nall: dummy_input reference_input {}\\\".format(self.model_name)\\n self.makefile += \\\"\\\\n\\\\n.PHONY: clean\\\\n\\\"\\n self.makefile += \\\"clean:\\\\n\\\\trm -rf {} dummy_input reference_input\\\\n\\\".format(self.model_name)\\n self.makefile += \\\"\\\\n\\\\n.PHONY: libpico-cnn.a\\\\n\\\"\\n self.makefile += \\\"libpico-cnn.a:\\\\n\\\\t$(MAKE) -C ../../../pico-cnn\\\"\\n\\n self.save(\\\"./generated_code/{}\\\".format(self.model_name))\",\n \"def generateMatrix(self):\\n if self.tokenWeights and self.extraFeatures:\\n nFeatures = self.wordId + self.wordId2 + len(self.EXTRA_WEIGHTS_LABELS)\\n logging.info('Exporting TOKEN WEIGHTS AND EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n # iterate through 1st sentence\\n for wId, val in doc['s1'].iteritems():\\n mtrx[docId, wId] = val\\n # then iterate thru 2nd sentence, store on 2ND PARTITION\\n for wId, val in doc['s2'].iteritems():\\n mtrx[docId, self.wordId + wId] = val\\n # finally extra features values stored at the end of the vector\\n for label, val in doc['extraFeatures'].iteritems():\\n mtrx[docId, self.wordId + self.wordId2 + self.EXTRA_WEIGHTS_LABELS.index(label)] = val\\n\\n elif self.tokenWeights and not self.extraFeatures:\\n nFeatures = self.wordId + self.wordId2\\n logging.info('Exporting TOKEN WEIGHTS %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n # iterate through 1st sentence\\n for wId, val in doc['s1'].iteritems():\\n mtrx[docId, wId] = val\\n # then iterate thru 2nd sentence, store on 2ND PARTITION\\n for wId, val in doc['s2'].iteritems():\\n mtrx[docId, self.wordId + wId] = val\\n else:\\n nFeatures = len(self.EXTRA_WEIGHTS_LABELS)\\n logging.info('Exporting EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n for label, val in doc['extraFeatures'].iteritems():\\n mtrx[docId, self.EXTRA_WEIGHTS_LABELS.index(label)] = val\\n logging.info('Matrix generated')\\n logging.info(mtrx.shape)\\n return mtrx\",\n \"def create_start_data(self):\\n\\t\\tdef inputMesh(feature_size):\\n\\t\\t\\tc1= np.expand_dims(np.array([0,-0.9]),0)\\n\\t\\t\\tc2= np.expand_dims(np.array([-0.9,0.9]),0)\\n\\t\\t\\tc3= np.expand_dims(np.array([0.9,0.9]),0)\\n\\t\\t\\tx1 = np.expand_dims(np.pad(np.array([0,-0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\\n\\t\\t\\tx2 = np.expand_dims(np.pad(np.array([-0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\\n\\t\\t\\tx3 = np.expand_dims(np.pad(np.array([0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\\n\\t\\t\\tedge_index = np.transpose(np.array([[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]])) # COO format\\n\\t\\t\\treturn np.concatenate((c1,c2,c3),axis=0), np.concatenate((x1,x2,x3),axis=0),edge_index\\n\\n\\t\\tc, x, edge_index = inputMesh(self.params.feature_size)# x is c with zeros appended, x=f ..pixel2mesh\\n\\t\\tdata_list_x = []\\n\\t\\tdata_list_c = []\\n\\t\\tdata_list_pid = []\\n\\t\\tfor i in range(self.params.batch_size):\\n\\t\\t\\tdata_list_x.append(Data(x=torch.Tensor(x).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\\n\\t\\t\\tdata_list_c.append(Data(x=torch.Tensor(c).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\\n\\t\\t\\tdata_list_pid.append(Data(x=torch.zeros(c.shape[0],1).type(dtypeL).requires_grad_(False)))\\n\\t\\tbatch_x = Batch.from_data_list(data_list_x)\\n\\t\\tbatch_c = Batch.from_data_list(data_list_c)\\n\\t\\tbatch_pid = Batch.from_data_list(data_list_pid)\\n\\t\\treturn batch_x, batch_c, batch_pid\",\n \"def process(self):\\n # Opening and preprocessing of the input file\\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\\n if self.options.mbtiles_fromdisk:\\n i_parm=10\\n if self.options.mbtiles_todisk:\\n i_parm=11\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :mbtiles from/to disk [\\\",i_parm,\\\"] mbtiles_fromdisk[\\\",self.options.mbtiles_fromdisk,\\\"] mbtiles_todisk[\\\",self.options.mbtiles_todisk,\\\"]\\\"\\n self.mbtiles_setup(i_parm)\\n return\\n else:\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :tile creation mbtiles[\\\",self.options.mbtiles,\\\"]\\\"\\n self.open_input()\\n # Generation of main metadata files and HTML viewers\\n self.generate_metadata()\\n # Generation of the lowest tiles\\n self.generate_base_tiles()\\n # Generation of the overview tiles (higher in the pyramid)\\n self.generate_overview_tiles()\\n # Generating of KML\\n self.generate_kml()\",\n \"def build(self, weight = 0.5):\\n \\n self.weight = weight\\n \\n # Defining weighting matrixes\\n self.processing_fw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\\n self.processing_bw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\\n self.processing_last_ht = torch.randn((self._hidden_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\\n \\n # These will only be applied to the intermediate hidden states\\n self.linear_fw = nn.Linear(self._seqlen - 1, 1).to(self.device)\\n self.linear_bw = nn.Linear(self._seqlen - 1, 1).to(self.device)\\n \\n self.compression = torch.randn((self._expansion_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\\n \\n if self._activation_fn == 'tanh' or isinstance(self._activation_fn, torch.nn.modules.activation.Tanh):\\n self._activation_fn = nn.Tanh()\\n elif self._activation_fn == 'sigmoid' or isinstance(self._activation_fn, torch.nn.modules.activation.Sigmoid):\\n self._activation_fn = nn.Sigmoid()\\n elif self._activation_fn == 'leaky ReLU' or isinstance(self._activation_fn, torch.nn.modules.activation.LeakyReLU):\\n self._activation_fn = nn.LeakyReLU()\\n else:\\n raise ValueError('Non-linear activation function must be \\\"tanh\\\", \\\"sigmoid\\\" or \\\"leaky ReLU\\\"')\\n \\n # Passing it onto the relevant device\\n self._activation_fn = self._activation_fn.to(self.device)\",\n \"def run(layers):\",\n \"def create_modules(self):\\n self.bitcell = self.replica_bitcell = self.mod_replica_bitcell()\\n self.add_mod(self.bitcell)\\n\\n # This is the replica bitline load column that is the height of our array\\n self.rbl = bitcell_array(name=\\\"bitline_load\\\", cols=1, rows=self.bitcell_loads)\\n self.add_mod(self.rbl)\\n\\n # FIXME: The FO and depth of this should be tuned\\n self.delay_chain = self.mod_delay_chain([self.delay_fanout]*self.delay_stages)\\n self.add_mod(self.delay_chain)\\n\\n self.inv = pinv()\\n self.add_mod(self.inv)\\n\\n self.access_tx = ptx(tx_type=\\\"pmos\\\")\\n self.add_mod(self.access_tx)\",\n \"def CreateDesignMatrix_X(z, x, y, n ):\\n if len(x.shape) > 1:\\n x = np.ravel(x)\\n y = np.ravel(y)\\n\\n N = len(x)\\n l = int((n+1)*(n+2)/2) \\n X = np.ones((N,l))\\n\\n for i in range(1,n+1):\\n q = int((i)*(i+1)/2)\\n for k in range(i+1):\\n X[:,q+k] = x**(i-k) * y**k\\n \\n X, z_, indicies = shuffle(X, z)\\n X_train, X_test, z_train, z_test = train_test_split(X, z_, test_size=split_train_test, random_state=seed, shuffle=False)\\n X_test, X_val, z_test, z_val = train_test_split(X_test, z_test, test_size=split_test_val, random_state=seed, shuffle=False)\\n\\n return X, X_train, X_test, X_val, z_train, z_test, z_val, indicies\",\n \"def generate_map(self):\\n\\n # Create main streets first\\n self.create_main_streets()\\n\\n # Then create the commercial buildings in the center of town\\n self.create_commercial_center()\\n\\n # Then create the neighborhoods that populate the rest of the city\\n while(self.create_neighborhood()):\\n pass\\n\\n # Clean up any invalid buildings that were created\\n self.delete_inaccessible_buildings()\",\n \"def build(self):\\n if self.is_built:\\n return\\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n\\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\\n assert self.nelements > 0, 'nelements=%s' % self.nelements\\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\\n #self.names = []\\n self.nelements //= self.ntimes\\n\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n self.node_element = np.zeros((self.ntotal, 2), dtype=idtype)\\n #oxx, oyy, txy, angle, major, minor, ovm\\n self.data = np.zeros((self.ntimes, self.nelements, 8), dtype=fdtype)\\n self.location = np.empty(self.ntotal, dtype='U8')\\n\\n self._times = np.zeros(self.ntimes, dtype=dtype)\",\n \"def create_grids(self):\\n \\n par = self.par\\n\\n # a. retirement\\n \\n # pre-decision states\\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\\n \\n # post-decision states\\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\\n \\n # b. working: state space (m,n,k) \\n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\\n\\n par.Nn = par.Nm\\n par.n_max = par.m_max + par.n_add\\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\\n\\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\\n\\n # c. working: w interpolant (and wa and wb and wq)\\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\\n par.a_max = par.m_max + par.a_add\\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\\n \\n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\\n par.b_max = par.n_max + par.b_add\\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\\n \\n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\\n \\n # d. working: egm (seperate grids for each segment)\\n \\n if par.solmethod == 'G2EGM':\\n\\n # i. dcon\\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\\n \\n # ii. acon\\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\\n par.a_acon = np.zeros(par.grid_b_acon.shape)\\n par.b_acon = par.grid_b_acon\\n\\n # iii. con\\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\\n \\n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\\n\\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\\n par.a_con = np.zeros(par.c_con.shape)\\n par.d_con = np.zeros(par.c_con.shape)\\n \\n elif par.solmethod == 'NEGM':\\n\\n par.grid_l = par.grid_m\\n\\n # e. shocks\\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\\n\\n if par.Neta > 1:\\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\\n else:\\n par.eta = np.ones(1)\\n par.w_eta = np.ones(1)\\n\\n # f. timings\\n par.time_work = np.zeros(par.T)\\n par.time_w = np.zeros(par.T)\\n par.time_egm = np.zeros(par.T)\\n par.time_vfi = np.zeros(par.T)\",\n \"def _setup(self) -> None:\\n #TODO: type\\n self.activation = self.params['activation']\\n\\n self.batchsize: int = self.params['batchsize']\\n\\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\\n\\n self.d: int = self.input_shape[1]\\n assert(not self.d == 0)\\n\\n self.n: int = int(sqrt(self.input_shape[2]))\\n assert(not self.n == 0)\\n\\n self.dtype: type = self.params['dtype']\\n\\n # initialize weights\\n self.W: List[tf.Tensor] = []\\n \\n for i in range(3):\\n #TODO: type\\n w_init = self.params['initializer_w']\\n if self.params['initializer_w' + str(i)] is not None:\\n w_init = self.params['initializer_w' + str(i)]\\n\\n w_stddev: float = self.params['stddev_w']\\n if self.params['stddev_w' + str(i)] is not None:\\n w_stddev = self.params['stddev_w' + str(i)]\\n\\n self.W.append(tf.get_variable(\\\"weights_\\\" + str(i),\\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\\n dtype = self.dtype,\\n initializer = w_init(stddev=w_stddev)))\\n\\n #TODO: type\\n b_init = self.params['initializer_b']\\n b_stddev = self.params['stddev_b']\\n self.B: tf.Tensor = tf.get_variable(\\\"biases\\\", shape = (1, self.d, 1),\\n dtype = self.dtype,\\n initializer = b_init(stddev=b_stddev))\\n\\n # create/load expand matrix\\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\\n self.expand: tf.Tensor = tf.get_variable(\\n \\\"expand\\\" + str(self.n),\\n shape = (self.n, self.n * self.n),\\n dtype = self.dtype,\\n initializer = tf.constant_initializer(make_expand(self.n)))\\n\\n # create/load tile matrix\\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\\n for i in range(1, self.n):\\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\\n\\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)\",\n \"def test_matrix_shapes(self):\\n k = [2, 3, 4, 5, 6]\\n mn = self.create_chain_model(k)\\n\\n max_states = max(k)\\n\\n assert mn.matrix_mode is False, \\\"Matrix mode flag was set prematurely\\\"\\n\\n mn.create_matrices()\\n\\n assert mn.matrix_mode, \\\"Matrix mode flag wasn't set correctly\\\"\\n\\n assert mn.unary_mat.shape == (max_states, 5)\",\n \"def get_all_coding_matrices(self):\\n class tran_matrix():\\n def __init__(self):\\n self.S = None\\n self.T = None\\n self.H1 = None\\n self.H2 = None\\n self.G1 = None\\n self.G2 = None\\n self.H = None\\n self.H2G2 = None\\n\\n def __init__(self, S, T, H1, H2, G1, G2, H, H2G2):\\n self.S = S\\n self.T = T\\n self.H1 = H1\\n self.H2 = H2\\n self.G1 = G1\\n self.G2 = G2\\n self.H = H\\n self.H2G2 = H2G2\\n\\n s = self.sources\\n s_edges = [self.out_edges(x) for x in s]\\n S = [list(set(self.get_edges_indices(src))) for src in s_edges]\\n\\n matrices = []\\n for dsts in self.dst_evolution_rec[::-1]:\\n T = [sorted(x) for x in dsts]\\n H2_raw = self.coding_matrix[T[0]].ix[S[1]].values\\n G2_raw = self.coding_matrix[T[1]].ix[S[1]].values\\n H1 = numpy_to_generic(self.coding_matrix[T[0]].ix[S[0]].values)\\n H2 = numpy_to_generic(H2_raw)\\n G1 = numpy_to_generic(self.coding_matrix[T[1]].ix[S[0]].values)\\n G2 = numpy_to_generic(G2_raw)\\n H = numpy_to_generic(self.coding_matrix[T[0]].values)\\n H2G2 = numpy_to_generic(np.hstack((H2_raw, G2_raw)))\\n temp = tran_matrix(S, T, H1, H2, G1, G2, H, H2G2)\\n matrices.append(temp)\\n\\n return matrices\",\n \"def main(self):\\n if self.mode==0: #drawing\\n self.draw()\\n self.graph_drawing=self.cleanGraph(self.graph_drawing)\\n #if len(self.graph_drawing)>1:\\n # self.function_interpolation=self.polynomialInterpolation2D(self.graph_drawing,1)\\n # self.graph_interpolation=self.sample(self.function_interpolation,len(self.graph_drawing))\\n elif self.mode==1: #construction\\n self.step+=1\\n self.time=self.step/self.max_step\\n if self.step>self.max_step:\\n self.mode=2\\n #self.graph_construction=self.discreteComplexComposeGraph(self.coefficients,self.time) #complex now\\n self.graph_construction=self.numpyComposeConstructionGraph(self.coefficients,t=self.time)\\n self.vectors=self.getVectors([(0,0)]+self.graph_construction)\\n self.graph_display.append(self.graph_construction[-1])\\n\\n elif self.mode==2:\\n self.draw()\",\n \"def __set_transform_matrices(self):\\n self.tf_matrices_list = []\\n\\n transform_matrix = eye(4) # creates a unit matrix via passing argument.\\n for i in range(self.joint_count):\\n transform_matrix = transform_matrix * self.__create_tf_matrix(self.alpha[i], self.a[i], self.d[i], self.q[i]).subs(self.dh_params)\\n self.tf_matrices_list.append(transform_matrix)\",\n \"def assemble_matrices(self):\\n \\n #Pointer reassignment for convenience\\n N = self.ngrids\\n\\n #Begin with a linked-list data structure for the transmissibilities,\\n #and one-dimenstional arrays for the diagonal of B and the flux vector\\n T = lil_matrix((N, N), dtype=np.double)\\n B = np.zeros(N, dtype=np.double)\\n Q = np.zeros(N, dtype=np.double)\\n\\n #Read in boundary condition types and values\\n bcs = self.input_data['boundary conditions']\\n bc_type_1 = bcs['left']['type'].lower()\\n bc_type_2 = bcs['right']['type'].lower()\\n bc_value_1 = bcs['left']['value']\\n bc_value_2 = bcs['right']['value']\\n \\n #Loop over all grid cells\\n for i in range(N):\\n\\n #Apply left BC\\n if i == 0:\\n T[i, i+1] = -self.compute_transmissibility(i, i + 1)\\n\\n if bc_type_1 == 'neumann':\\n T[i, i] = T[i,i] - T[i, i+1]\\n elif bc_type_1 == 'dirichlet':\\n #Computes the transmissibility of the ith block\\n T0 = self.compute_transmissibility(i, i)\\n T[i, i] = T[i,i] - T[i, i+1] + 2.0 * T0\\n Q[i] = 2.0 * T0 * bc_value_1\\n else:\\n pass #TODO: Add error checking here if no bc is specified\\n\\n #Apply right BC\\n elif i == (N - 1):\\n T[i, i-1] = -self.compute_transmissibility(i, i - 1)\\n\\n if bc_type_2 == 'neumann':\\n T[i, i] = T[i,i] - T[i, i-1]\\n elif bc_type_2 == 'dirichlet':\\n #Computes the transmissibility of the ith block\\n T0 = self.compute_transmissibility(i, i)\\n T[i, i] = T[i, i] - T[i, i-1] + 2.0 * T0\\n Q[i] = 2.0 * T0 * bc_value_2\\n else:\\n pass #TODO:Add error checking here if no bc is specified\\n\\n #If there is no boundary condition compute interblock transmissibilties\\n else:\\n T[i, i-1] = -self.compute_transmissibility(i, i-1)\\n T[i, i+1] = -self.compute_transmissibility(i, i+1)\\n T[i, i] = (self.compute_transmissibility(i, i-1) +\\n self.compute_transmissibility(i, i+1))\\n\\n #Compute accumulations\\n B[i] = self.compute_accumulation(i)\\n\\n #If constant-rate wells are present, add them to the flux vector\\n if self.rate_well_grids is not None:\\n Q[self.rate_well_grids] += self.rate_well_values\\n\\n \\n #Return sparse data-structures\\n return (T.tocsr(), \\n csr_matrix((B, (np.arange(N), np.arange(N))), shape=(N,N)), \\n Q)\",\n \"def run(self):\\n super().run()\\n # more verbose creation date for clarity\\n creation_date = f'20{self.creation_date}'\\n make_e3sm_to_cmip_maps(self.config, self.logger, self.mesh_short_name,\\n creation_date, self.ntasks)\",\n \"def build(self, input_shape):\\n\\n # get shape of input matrix x\\n self.num_of_vertices = input_shape[1]\\n self.num_of_features = input_shape[2]\\n self.num_of_timesteps = input_shape[3]\\n #self.W_1.shape = (num_of_timesteps,)\\n #self.W_2.shape = (num_of_features, num_of_timesteps)\\n #self.W_3.shape = (num_of_features,)\\n #self.b_s.shape = (1, num_of_vertices, num_of_vertices)\\n #self.V_s.shape = (num_of_vertices, num_of_vertices)\\n\\n self.w1 = self.add_weight(name='w1', shape=(self.num_of_timesteps, ),\\n initializer='glorot_normal', trainable=True)\\n self.w2 = self.add_weight(name='w2', shape=(self.num_of_features, self.num_of_timesteps),\\n initializer='glorot_normal', trainable=True)\\n self.w3 = self.add_weight(name='w3', shape=(self.num_of_features,),\\n initializer='glorot_normal', trainable=True)\\n self.b = self.add_weight(name='b', shape=(1, self.num_of_vertices, self.num_of_vertices),\\n initializer='zeros', trainable=True)\\n self.v = self.add_weight(name='v', shape=(self.num_of_vertices, self.num_of_vertices),\\n initializer='glorot_normal', trainable=True)\\n\\n super(Spatial_Attention_layer, self).build(input_shape)\",\n \"def generate(self, n_enemies, n_blocks):\\n self.create_map()\\n self.create_floor()\\n self.player = self.create_player_at(0, 0)\\n self.create_dummy_obj_at(0, 1)\\n self.create_dummy_obj_at(1, 0)\\n self.create_soft_block_at(0, 2)\\n self.create_soft_block_at(2, 0)\\n self.create_hard_blocks() \\n self.create_enemies(n_enemies)\\n self.create_soft_blocks(n_blocks) \\n self.clear_dummy_obj()\",\n \"def model(inputs):\\n outputs = {}\\n\\n # First, build the encoder\\n encoder_fn = _get_network(params.encoder_name)\\n with tf.variable_scope('encoder', reuse=reuse):\\n # Produces id/pose units\\n enc_outputs = encoder_fn(inputs['images_1'], params, is_training)\\n outputs['ids_1'] = enc_outputs['ids']\\n\\n # Second, build the decoder and projector\\n decoder_fn = _get_network(params.decoder_name)\\n with tf.variable_scope('decoder', reuse=reuse):\\n outputs['voxels_1'] = decoder_fn(outputs['ids_1'], params, is_training)\\n if run_projection:\\n projector_fn = _get_network(params.projector_name)\\n with tf.variable_scope('projector', reuse=reuse):\\n outputs['projs_1'] = projector_fn(\\n outputs['voxels_1'], inputs['matrix_1'], params, is_training)\\n # Infer the ground-truth mask\\n with tf.variable_scope('oracle', reuse=reuse):\\n outputs['masks_1'] = projector_fn(inputs['voxels'], inputs['matrix_1'],\\n params, False)\\n\\n # Third, build the entire graph (bundled strategy described in PTN paper)\\n for k in range(1, params.step_size):\\n with tf.variable_scope('projector', reuse=True):\\n outputs['projs_%d' % (k + 1)] = projector_fn(\\n outputs['voxels_1'], inputs['matrix_%d' %\\n (k + 1)], params, is_training)\\n with tf.variable_scope('oracle', reuse=True):\\n outputs['masks_%d' % (k + 1)] = projector_fn(\\n inputs['voxels'], inputs['matrix_%d' % (k + 1)], params, False)\\n\\n return outputs\",\n \"def synthetic_gen(self):\\r\\n logging.debug('generating synthetic map...')\\r\\n data = self.realData\\r\\n unit = Params.unitGrid\\r\\n x_min = np.floor(Params.LOW[0] / unit) * unit\\r\\n x_max = np.ceil(Params.HIGH[0] / unit) * unit\\r\\n y_min = np.floor(Params.LOW[1] / unit) * unit\\r\\n y_max = np.ceil(Params.HIGH[1] / unit) * unit\\r\\n\\r\\n x_CELL = int(np.rint((x_max - x_min) / unit))\\r\\n y_CELL = int(np.rint((y_max - y_min) / unit))\\r\\n\\r\\n self.root.n_box = np.array([[x_min, y_min], [x_max, y_max]])\\r\\n\\r\\n self.mapp = np.zeros((x_CELL, y_CELL)) - 1 # ## initialize every cell with -1\\r\\n for i in range(Params.NDATA): # ## populate the map\\r\\n point = data[:, i]\\r\\n cell_x = int(np.floor((point[0] - x_min) / unit))\\r\\n cell_y = int(np.floor((point[1] - y_min) / unit))\\r\\n if self.mapp[cell_x, cell_y] != -1:\\r\\n self.mapp[cell_x, cell_y] += 1\\r\\n else:\\r\\n self.mapp[cell_x, cell_y] = 1\\r\\n\\r\\n for i in range(x_CELL): # ## perturb the counts\\r\\n for j in range(y_CELL):\\r\\n if self.mapp[i, j] != -1:\\r\\n self.mapp[i, j] += np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\\r\\n else:\\r\\n self.mapp[i, j] = np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\\r\\n # if noisy count is negative, ignore the noise and generate no points\\r\\n if self.mapp[i, j] < 0:\\r\\n self.mapp[i, j] = 0\",\n \"def build(self, input_shape):\\n\\n # get shape of input matrix x\\n num_of_vertices = input_shape[1]\\n num_of_features = input_shape[2]\\n num_of_timesteps = input_shape[3]\\n #self.U_1.shape = (num_of_vertices,)\\n #self.U_2.shape = (num_of_features, num_of_vertices)\\n #self.U_3.shape = (num_of_features,)\\n #self.b_e.shape = (1, num_of_timesteps, num_of_timesteps)\\n #self.V_e.shape = (num_of_timesteps, num_of_timesteps)\\n\\n self.u1 = self.add_weight(name='u1', shape=(num_of_vertices, ),\\n initializer='glorot_normal', trainable=True)\\n self.u2 = self.add_weight(name='u2', shape=(num_of_features, num_of_vertices),\\n initializer='glorot_normal', trainable=True)\\n self.u3 = self.add_weight(name='u3', shape=(num_of_features,),\\n initializer='glorot_normal', trainable=True)\\n self.b = self.add_weight(name='b', shape=(1, num_of_timesteps, num_of_timesteps),\\n initializer='zeros', trainable=True)\\n self.v = self.add_weight(name='v', shape=(num_of_timesteps, num_of_timesteps),\\n initializer='glorot_normal', trainable=True)\\n\\n super(Temporal_Attention_layer, self).build(input_shape)\",\n \"def _generate_weighted_matrices(self):\\n self.degree_weighted_matrices = dict()\\n mes = []\\n args = []\\n for metaedge, matrix in self.adj_matrices.items():\\n mes.append(metaedge)\\n args.append({'matrix': matrix, 'w': self.w, 'degree_fwd': self.out_degree[metaedge],\\n 'degree_rev': self.in_degree[metaedge]})\\n res = parallel_process(array=args, function=mt.weight_by_degree, use_kwargs=True, n_jobs=self.n_jobs,\\n front_num=0)\\n for metaedge, matrix in zip(mes, res):\\n self.degree_weighted_matrices[metaedge] = matrix\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6531163","0.6477542","0.6408404","0.6279157","0.6247964","0.6191774","0.61850005","0.61850005","0.61787516","0.6170357","0.61396635","0.6123712","0.60545397","0.60288393","0.5991115","0.5973127","0.5918543","0.5913769","0.5901594","0.5899731","0.5898971","0.58831286","0.58804584","0.58766323","0.5869766","0.58679855","0.5865554","0.58629066","0.58567184","0.58401597","0.58365625","0.58092135","0.57938963","0.5774668","0.5770658","0.5770017","0.57662517","0.57611674","0.57422566","0.57357156","0.57357156","0.5735236","0.57335174","0.5727601","0.5721716","0.57196295","0.5718443","0.5700203","0.56963","0.5691346","0.56845766","0.56845343","0.56797886","0.5674884","0.56687564","0.56672734","0.5652344","0.5640557","0.56358016","0.5626679","0.5622876","0.5609762","0.56035614","0.5587517","0.55868894","0.55802166","0.55796844","0.55681604","0.55621755","0.55541503","0.5542825","0.5536091","0.552949","0.5521875","0.55176824","0.5510517","0.5510173","0.5507711","0.5506627","0.5502661","0.549964","0.549946","0.54992545","0.549906","0.54901695","0.548742","0.54853594","0.5485176","0.5485123","0.5478058","0.5474725","0.5470166","0.54687434","0.5462698","0.546113","0.545442","0.54536355","0.54504526","0.54503495","0.5449517","0.5446569"],"string":"[\n \"0.6531163\",\n \"0.6477542\",\n \"0.6408404\",\n \"0.6279157\",\n \"0.6247964\",\n \"0.6191774\",\n \"0.61850005\",\n \"0.61850005\",\n \"0.61787516\",\n \"0.6170357\",\n \"0.61396635\",\n \"0.6123712\",\n \"0.60545397\",\n \"0.60288393\",\n \"0.5991115\",\n \"0.5973127\",\n \"0.5918543\",\n \"0.5913769\",\n \"0.5901594\",\n \"0.5899731\",\n \"0.5898971\",\n \"0.58831286\",\n \"0.58804584\",\n \"0.58766323\",\n \"0.5869766\",\n \"0.58679855\",\n \"0.5865554\",\n \"0.58629066\",\n \"0.58567184\",\n \"0.58401597\",\n \"0.58365625\",\n \"0.58092135\",\n \"0.57938963\",\n \"0.5774668\",\n \"0.5770658\",\n \"0.5770017\",\n \"0.57662517\",\n \"0.57611674\",\n \"0.57422566\",\n \"0.57357156\",\n \"0.57357156\",\n \"0.5735236\",\n \"0.57335174\",\n \"0.5727601\",\n \"0.5721716\",\n \"0.57196295\",\n \"0.5718443\",\n \"0.5700203\",\n \"0.56963\",\n \"0.5691346\",\n \"0.56845766\",\n \"0.56845343\",\n \"0.56797886\",\n \"0.5674884\",\n \"0.56687564\",\n \"0.56672734\",\n \"0.5652344\",\n \"0.5640557\",\n \"0.56358016\",\n \"0.5626679\",\n \"0.5622876\",\n \"0.5609762\",\n \"0.56035614\",\n \"0.5587517\",\n \"0.55868894\",\n \"0.55802166\",\n \"0.55796844\",\n \"0.55681604\",\n \"0.55621755\",\n \"0.55541503\",\n \"0.5542825\",\n \"0.5536091\",\n \"0.552949\",\n \"0.5521875\",\n \"0.55176824\",\n \"0.5510517\",\n \"0.5510173\",\n \"0.5507711\",\n \"0.5506627\",\n \"0.5502661\",\n \"0.549964\",\n \"0.549946\",\n \"0.54992545\",\n \"0.549906\",\n \"0.54901695\",\n \"0.548742\",\n \"0.54853594\",\n \"0.5485176\",\n \"0.5485123\",\n \"0.5478058\",\n \"0.5474725\",\n \"0.5470166\",\n \"0.54687434\",\n \"0.5462698\",\n \"0.546113\",\n \"0.545442\",\n \"0.54536355\",\n \"0.54504526\",\n \"0.54503495\",\n \"0.5449517\",\n \"0.5446569\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":82996,"cells":{"query":{"kind":"string","value":"Forward pass of the bidirectional hidden states."},"document":{"kind":"string","value":"def forward(self, output):\n \n hidden_states = self.extract_hidden_states(output)\n \n # Obtaining the attention weights\n weighted_states = self.w1(hidden_states)\n activated_states = self.tanh(weighted_states)\n score_weights = self.w2(activated_states)\n attention_weights = self.softmax(score_weights)\n \n # Applying attention to the matrix with hidden states\n attentional_vector = torch.bmm(torch.transpose(attention_weights,2,1),hidden_states) \n attentional_vector = self.fc(torch.transpose(attentional_vector,2,1)).squeeze(2)\n attentional_vector = self._activation_fn(attentional_vector)\n \n return attentional_vector"},"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 _bridge_bidirectional_hidden(self, hidden):\n num_layers = hidden.size(0) // 2\n _, batch_size, hidden_size = hidden.size()\n return hidden.view(num_layers, 2, batch_size, hidden_size)\\\n .transpose(1, 2).contiguous().view(num_layers, batch_size, hidden_size * 2)","def forward(self, states):\n raise NotImplementedError()","def init_hidden(self, batch_size):\r\n \r\n self.hidden_state = (\r\n torch.zeros(((1+self.bidirectional)*self.num_layers,\r\n batch_size,\r\n self.hidden_size)).to(self.device),\r\n torch.zeros(((1+self.bidirectional)*self.num_layers, \r\n batch_size, \r\n self.hidden_size)).to(self.device))","def toggle_hidden(self):\n AbstractChild.toggle_hidden(self)\n self.accFrame.update_values()\n self.botFrame.update_values()\n # On toggle hidden\n self.on_toggle_hidden()","def hidden(self):\n return self._hidden","def forward(self, node_hidden, edge_hidden, adj_matrix, mask):\n # x.shape = (batch, max_length, d_atom)\n node_hidden = self.dropout(self.norm(node_hidden))\n node_hidden_first, edge_hidden_temp = self.self_attn(node_hidden, node_hidden, edge_hidden, adj_matrix, mask)\n # the first residue block\n node_hidden_first = node_hidden + self.dropout(self.norm(node_hidden_first))\n node_hidden_second = self.feed_forward(node_hidden_first)\n # the second residue block\n return node_hidden + node_hidden_first + self.dropout(self.norm(node_hidden_second)), edge_hidden","def hidden(self, hidden):\n\n self._hidden = hidden","def forward(self, input, states):\n (hidden, cell) = states\n\n input = input + self.transform(hidden)\n\n forget_gate = torch.sigmoid(self.forget(input))\n input_gate = torch.sigmoid(self.input(input))\n output_gate = torch.sigmoid(self.output(input))\n state_gate = torch.tanh(self.state(input))\n\n # Update internal cell state\n cell = forget_gate * cell + input_gate * state_gate\n hidden = output_gate * torch.tanh(cell)\n\n return hidden, cell","def _transit_state(self) -> None:\n pass","def _TransformHidden(self, _):\n raise NotImplementedError()","def extract_hidden_states(self, output):\n \n # Extracting the forward and backward hidden states from the last BiLSTM layer\n # output (batch_size, sequence length, 2 * hidden dim)\n output_fw = output[:,:,0:self._hidden_size]\n output_bw = output[:,:,self._hidden_size:]\n \n hidden_states = torch.cat((output_fw, output_bw),-1)\n \n return hidden_states","def forward(self, input, hidden_states):\n h, c = self.ih2h(input, hidden_states[0])\n next_hiddens = [(h, c)]\n h, c = self.h2h(h, hidden_states[1])\n next_hiddens.append((h, c))\n output = self.log_softmax(self.h2o(h))\n return output, next_hiddens","def forward(self, hidden: Union[torch.Tensor, Tuple[torch.Tensor, ...]]) -> Union[torch.Tensor, Tuple[torch.Tensor, ...]]:\n # First, map the non-tuple version to a 1-tuple for easier processing.\n # We will undo this at the end\n if not isinstance(hidden, tuple):\n hidden = (hidden,)\n\n batch_size, hidden_size = hidden[0].size()\n\n # If we are going to share parameters across the forward and backward\n # directions, then we need to separate them in the tensors\n if self.share_bidirectional_parameters:\n # shape: (batch_size, 2, encoder_hidden_size // 2)\n hidden = tuple(h.view(batch_size, 2, -1) for h in hidden)\n\n # Apply the bridge\n output = tuple(layer(h) for layer, h in zip(self.layers, hidden))\n\n # Reshape the tensors if the parameters are shared\n if self.share_bidirectional_parameters:\n # shape: (batch_size, decoder_hidden_size)\n output = tuple(h.view(batch_size, -1) for h in output)\n\n # Undo the tuple if there's only 1 element\n if len(output) == 1:\n output = output[0]\n return output","def hidden():\n return False","def forward(self, hidden_states):\n # Common transformations (dense layer, layer norm + activation function) performed on text, KG and protein data\n # transform is initialized in the parent BigBirdLMPredictionHead class\n hidden_states = self.transform(hidden_states)\n\n # The first part is processed with the text decoder, the second with the entity decoder, and the third with the\n # protein decoder to map to the text, kg, and protein vocab size, respectively\n text_hidden_states_to_vocab = self.text_decoder(hidden_states[:, : self.kg_start_idx])\n ent_hidden_states_to_kg_vocab = self.entity_decoder(\n hidden_states[:, self.kg_start_idx : self.prot_start_idx]\n )\n prot_hidden_states_to_prot_vocab = self.prot_decoder(\n hidden_states[:, self.prot_start_idx :]\n )\n\n return (\n text_hidden_states_to_vocab,\n ent_hidden_states_to_kg_vocab,\n prot_hidden_states_to_prot_vocab,\n )","def detach_hidden(self, zero=False):\n if zero:\n self.hidden = self._make_hidden(self.batch_size)\n else:\n self.hidden = self.hidden.detach()","def init_hidden_state(self, encoder_out: torch.Tensor):\n pass","def forward(self, x, hidden):\n emb_x = self.emb_layer(x)\n lstm_out, hidden = self.lstm(emb_x, hidden)\n if self.bidirectional:\n # separate to forward and backward\n # following code reshapes LSTM output to:\n # (batch size, seq length, num directions, hidden dimensions)\n # where direction '0' is forward and direction '1' is backward\n lstm_out = lstm_out.contiguous().view(-1, self.seq_len, 2, self.hidden_dim)\n # get backward output in first node\n lstm_out_bw = lstm_out[:, 0, 1, :]\n # get forward output in last node\n lstm_out_fw = lstm_out[:, -1, 0, :]\n # we may simple concatenate forward & backward outputs,\n # or add them, multiply or average; in this case i used average\n lstm_out = torch.add(input=lstm_out_bw, alpha=1, other=lstm_out_fw)\n lstm_out = torch.div(lstm_out, 2)\n else:\n lstm_out = lstm_out[:, -1]\n \n assert lstm_out.shape[-1] == self.hidden_dim, (lstm_out.shape, self.hidden_dim)\n lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)\n \n d_out = self.dropout(lstm_out)\n fc_out = self.output_layer(d_out)\n sig_out = torch.sigmoid(fc_out)\n \n # return last sigmoid output and hidden state\n return sig_out, hidden","def test_switch_hidden1(self):\n self.test_object.switch_hidden()\n self.assertFalse(self.test_object.get_hidden())","def forward(self, input, hidden, key=None):\n for cell_id, cell in enumerate(self.cells):\n hidden[cell_id] = cell(input, hidden[cell_id])\n if not isinstance(hidden[cell_id], (list, tuple)):\n hidden[cell_id] = [hidden[cell_id]]\n input = hidden[cell_id][0]\n\n if key is not None:\n logits = self.policies[key](hidden[-1][0])\n values = self.values[key](hidden[-1][0])\n return logits, values, hidden\n\n return hidden","def hidden(self) -> Generator[None, None, None]:\n if self._hidden_level == 0:\n self.hide()\n self._hidden_level += 1\n try:\n yield\n finally:\n self._hidden_level -= 1\n if self._hidden_level == 0:\n self.show()","def toggle_hidden(self):\n if self.hidden:\n self.show()\n else:\n self.hide()","def extract_hidden_states(self, output):\n # Intermediate hidden states\n output_fw_intermediate = output[:,:-1,0:self._hidden_size]\n output_bw_intermediate = output[:,1:,self._hidden_size:] \n \n # Last hidden states\n output_fw = output[:,-1,0:self._hidden_size]\n output_bw = output[:,0,self._hidden_size:]\n last_ht = torch.cat((output_fw, output_bw), -1)\n \n return last_ht, output_fw_intermediate, output_bw_intermediate","def detach_hidden(self, zero=False):\n if zero:\n self.hidden = self._make_hidden(self.batch_size)\n else:\n self.hidden[0].detach()","def test_switch_hidden2(self):\n self.test_object.switch_hidden()\n self.test_object.switch_hidden()\n self.assertTrue(self.test_object.get_hidden())","def forward(self, x):\n x, self.hidden = self.gru(x, self.hidden)\n self.detach_hidden()\n x = self.dropout(x)\n x = self.out(x)\n return x","def backward(self, dout):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n for l in range(len(self.layers)-1,-1,-1):\n act_dout = self.activations[l].backward(dout)\n dout = self.layers[l].backward(act_dout)\n ########################\n # END OF YOUR CODE #\n #######################\n\n return","def _set_state_after_forward(self):\n for chunk_id, chunk in self.client.chunk_list.generate_chunk():\n if (\n chunk.get_state() == ChunkState.HOLD\n or chunk.get_state() == ChunkState.HOLD_AFTER_FWD\n ):\n chunk.set_unused()\n self.client.set_all_tensors_state_in_chunk(chunk_id, TensorState.HOLD)","def stabilize(self, hidden, num_iters=1):\n for i in range(num_iters):\n g_off, hidden = self.add_transit(old_hidden=hidden)\n return g_off, hidden","def propdown(self, hid):\n pre_sigmoid_activation = \\\n T.dot(hid, self.hidden_layer.W.T) + self.vbias\n return [pre_sigmoid_activation, T.nnet.sigmoid(pre_sigmoid_activation)]","def add_state_desires(self):\n raise NotImplementedError()","def init_hidden(self):\n # TODO ========================\n # initialize the hidden states to zero\n\n initial_hidden = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)\n return initial_hidden # a parameter tensor of shape (self.num_layers, self.batch_size, self.hidden_size)","def initialize_state(self):\n super(InverseChain, self).initialize_state()","def _init_state(self, encoder_hidden):\n if encoder_hidden is None:\n return None\n if isinstance(encoder_hidden, tuple):\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\n else:\n encoder_hidden = self._cat_directions(encoder_hidden)\n return encoder_hidden","def _init_state(self, encoder_hidden):\n if encoder_hidden is None:\n return None\n if isinstance(encoder_hidden, tuple):\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\n else:\n encoder_hidden = self._cat_directions(encoder_hidden)\n return encoder_hidden","def setIsolateHidden( self, state ):\n self._isolatedHidden = state\n \n super(XNode, self).setVisible(self.isVisible())","def gibbs_step(self, visible):\n hidden_prob = self.probabilities_hidden(visible)\n hidden_state = self.sample(hidden_prob)\n visible_prob = self.probabilities_visible(hidden_state)\n visible_state = visible_prob\n return hidden_prob, hidden_state, visible_prob, visible_state","def post_backward_generator(self):\n pass","def reset_hidden(self, hidden, reset_flags):\n # detach it from history (pytorch mechanics)\n if self.rnn_type in ['lstm', 'mylstm']:\n h = Variable(hidden[0].data)\n c = Variable(hidden[1].data)\n hidden = (h, c)\n for b, flag in enumerate(reset_flags):\n if flag.data[0] == 1: # data[0] access the data in Variable\n hidden[0][:, b, :].data.fill_(0)\n hidden[1][:, b, :].data.fill_(0)\n elif self.rnn_type == 'gru':\n hidden = Variable(hidden.data)\n for b, flag in enumerate(reset_flags):\n if flag.data[0] == 1: # data[0] access the data in Variable\n hidden[:, b, :].data.fill_(0)\n else:\n print(\"Not support this type yet.\")\n exit(0)\n return hidden","def forward(self):\n raise NotImplemented","def forward(self):\n raise NotImplemented","def forward(self):\n raise NotImplemented","def forward(self, input, hidden):\n combined = torch.cat((input, hidden), 1)\n hidden = self.i2h(combined)\n output = self.i2o(combined)\n output = self.softmax(output)\n return output, hidden","def backward(self):\n raise NotImplemented","def backward(self):\n raise NotImplemented","def backward(self):\n raise NotImplemented","def hidden(self):\n return self._hidden","def forward(self, state):\n x = self.nonlin(self.fc1(self.in_fn(state)))\n x = self.drop_layer(x)\n x = self.nonlin(self.fc2(x))\n x = self.drop_layer(x)\n return self.fc3(x)","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def backward(self):\n raise NotImplementedError","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def forward(self, inp, state):\n emb = self.drop(self.encoder(inp))\n y, state_next = self.rnn(emb, state)\n y = self.drop(y)\n y = self.decoder(y)\n return y, state_next","def flip(self):","def forward(self, state):\n x = self.conv(state).view(-1, self.hid_size)\n x = self.fc1(x)\n x = F.relu(x)\n return self.fc2(x)","def is_hidden(self):\n return self.has_label(HIDDEN_LABEL)","def forward_pass(self):","def toggle(self) -> None:","def toggle(self) -> None:","def hidden(self) -> bool:\n return False","def hidden(self) -> bool:\n return False","def init_hidden(self, batch_size, device):\n if self.mode == 'LSTM':\n return (torch.ones((1+self.bidirectional , batch_size, self.hidden_dim), device=device),\n torch.ones((1+self.bidirectional, batch_size, self.hidden_dim), device=device))\n else:\n return torch.ones((1+self.bidirectional, batch_size, self.hidden_dim), device=device)","def post_backward_discriminator(self):\n pass","def forward_step(self, layer: int, hidden: AmbiguousHidden, input_: Tensor) -> AmbiguousHidden:\n hx, cx = hidden\n\n # Forget gate\n f_g = torch.sigmoid(self.gates[layer]['if'](input_) + self.gates[layer]['hf'](hx))\n\n # Input gate\n i_g = torch.sigmoid(self.gates[layer]['ii'](input_) + self.gates[layer]['hi'](hx))\n\n # Output gate\n o_g = torch.sigmoid(self.gates[layer]['io'](input_) + self.gates[layer]['ho'](hx))\n\n # Intermediate cell state\n c_tilde_g = torch.tanh(self.gates[layer]['ig'](input_) + self.gates[layer]['hg'](hx))\n\n # New cell state\n cx = f_g * cx + i_g * c_tilde_g\n\n # New hidden state\n hx = o_g * torch.tanh(cx)\n\n return hx, cx","def toggle(self):","def init_hidden_state(self,batch_size):\n h = torch.zeros(batch_size,self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size,self.decoder_dim).to(device)\n return h, c","def backward(self, top, propagate_down, bottom):\n\t\tpass","def flip_state(self):\n logging.debug(\"element selected\")\n if len(self._contents) == 0:\n self.deactivate()\n else:\n if self._contents[self.pointer][2] == 'exit':\n self.deactivate()\n return\n self.states[self.pointer] = not self.states[self.pointer] #Just inverting.\n self.refresh()","def toggle_hidden(self):\n self.show_hidden = not self.show_hidden\n self.reload('.')","def _repackage(self):\n self.hidden = _var(self.hidden.data)\n if self.G.ntype == \"lstm\":\n self.state = _var(self.state.data)","def forward(self, input, hidden):\r\n output, hidden = self.rnn(input, hidden)\r\n output = f.log_softmax(self.out(output.squeeze(1)), 1)\r\n return output, hidden","def hidden(self, value):\n if value is not None:\n value.get_shape().assert_is_compatible_with(self._output_shape)\n self._hidden = value","def forward(self, x, hidden):\n batch_size=x.shape[0]\n\n x = self.embed(x)\n\n x,hidden = self.lstm(x,hidden)\n\n x = x.reshape(-1,self.hidden_dim)\n\n x = self.drp(x)\n\n x = self.fc(x)\n\n sig_out = self.sigmoid(x)\n\n # return last sigmoid output and hidden state\n sig_out = sig_out.reshape(batch_size,-1)\n sig_out = sig_out[:,-1]\n\n return sig_out, hidden","def forward_backward(observations):\n\n # -------------------------------------------------------------------------\n # YOUR CODE GOES HERE\n #\n # observations = [(4, 3), (4, 2), (3, 2), (4, 0), (2, 0), (2, 0), (3, 2), \n # (4, 2), (2, 3), (3, 5)]\n num_time_steps = len(observations)\n forward_messages = [None] * num_time_steps\n forward_messages[0] = prior_matrix\n # # # TODO: Compute the forward messages\n for i,x_i in enumerate(observations):\n if x_i:\n obs_index = obs_state_index_map[x_i]\n pi_0 = forward_messages[i]\n # print(len(B[:obs_index]))\n weights = np.multiply(pi_0, B[:,obs_index])\n # x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\n else:\n weights = forward_messages[i]\n # print(weights)\n x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\n if i+1 < len(forward_messages):\n forward_messages[i+1] = x#normalize(x)\n # break\n\n ## forward messages as dictionary\n # for_dict = [None]*num_time_steps\n # for j,f in enumerate(forward_messages):\n # x = Distribution()\n # for i,x_i in enumerate(f):\n # if x_i == 0:\n # continue\n # # print(i,x_i)\n # x[all_possible_hidden_states[i]] = x_i\n # for_dict[j] = x.renormalize()\n # print(for_dict[3])\n\n # print('--------------\\n-----------------\\n')\n\n\n backward_messages = [None] * num_time_steps\n # backward_messages[-1] = [1]*len(prior_matrix)\n message = np.ones(len(all_possible_hidden_states), dtype=np.float64)\n backward_messages[-1] = message/len(all_possible_hidden_states)\n \n# ****\n ## Backwards messages\n for i,x_i in enumerate(reversed(observations)):\n # print(x_i)\n if x_i:\n obs_index = obs_state_index_map[x_i]\n pi = backward_messages[-1-i]\n weights = np.multiply(pi, B[:,obs_index])\n else:\n weights = backward_messages[-1-i]\n # print(i)\n x = sum([A[:,j]*w_i for j,w_i in enumerate(weights)])\n\n if i+1 < len(backward_messages):\n backward_messages[-2-i] = x#normalize(x)\n\n ## backward messages as dictionary\n # back_dict = [None]*num_time_steps\n # for j,b in enumerate(backward_messages):\n # x = Distribution()\n # if b == None:\n # continue\n # for i,x_i in enumerate(b):\n # if x_i == 0 or x_i==None:\n # continue\n # # print(i,x_i)\n # x[all_possible_hidden_states[i]] = x_i\n # back_dict[j] = x.renormalize()\n \n # print(back_dict[0])\n # print(A[:10,:10])\n # print('\\n-----------------\\n', B[:10,:10])\n\n # print(backward_messages[2])\n # backward_messages[0] = forward_messages[0]\n # # ## marginals as matrix\n marginals = [None] * num_time_steps \n for i,x_i in enumerate(observations):\n if x_i:\n obs_index = obs_state_index_map[x_i]\n marginals[i] = np.multiply(np.multiply(backward_messages[i],\n forward_messages[i]),\n B[:,obs_index])\n else:\n marginals[i] = np.multiply(backward_messages[i],forward_messages[i])\n # if i == 0:\n # marginals[i] = np.multiply(backward_messages[i], B[:,obs_index])\n # elif i == len(observations)-1:\n # marginals[i] = np.multiply(forward_messages[i], B[:,obs_index])\n # else:\n\n ## marginals as dictionary\n marg_dict = [None]*num_time_steps\n for j,m in enumerate(marginals):\n x = Distribution()\n for i,x_i in enumerate(m):\n if x_i == 0 or x_i==None:\n continue\n x[all_possible_hidden_states[i]] = x_i\n marg_dict[j] = x.renormalize()\n # print(marginals[i])\n # print(A[:10, :10], '\\n')\n # print(B[:10, :10], '\\n')\n # print(marg_dict)\n return marg_dict","def detach_hidden(hidden: Any) -> Any:\n return apply_to_tensor(hidden, Tensor.detach)","def hidden_layers(self):\n\t\tif self.hidden is None:\n\t\t\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\n\t\t\tlast_hidden = self.x\n\t\t\tif self.covnet == 1:\n\t\t\t\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\n\t\t\telif self.covnet == 2:\n\t\t\t\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\n\t\t\t\t self.layerSize[0], self.layerSize[1])\n\t\t\telse:\n\n\t\t\t\tself._drouput = 'dr'\n\t\t\t\t# self.hidden.append(self.x)\n\t\t\t\tfor i in range(1, len(self.all_layer_sizes)):\n\t\t\t\t\tname_scope = 'hidden' + str(i - 1)\n\t\t\t\t\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\n\t\t\t\t\tactivation_function = self.activation_function\n\t\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\n\t\t\t\t\t last_hidden)\n\t\t\t\tname_scope = 'final_layer'\n\t\t\t\trow_size, col_size = self.layerSize[-1], self.num_of_classes\n\t\t\t\tactivation_function = None\n\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\n\t\treturn self.hidden","def backward(self, top, propagate_down, bottom):\r\n pass","def init_hidden(self):\n pass","def init_hidden(self):\n pass","def _hidden_activation(self, inputs):\n if self.act_enc is None:\n act_enc = lambda x: x\n else:\n act_enc = self.act_enc\n return act_enc(self._mappings(inputs))","def forward(self)->None:","def transparent_forward(self, inp, hidden=None, give_gates=False, debug=False):\n\n lseq = inp.shape[0]\n nseq = inp.shape[1]\n # ispad = (input == self.padding)\n\n if hidden is None:\n hidden = self.init_hidden(nseq)\n\n H = torch.zeros(lseq, self.nhid, nseq)\n if give_gates:\n Z = torch.zeros(lseq, self.nhid, nseq)\n R = torch.zeros(lseq, self.nhid, nseq)\n \n # because pytorch only returns hidden activity in the last time step,\n # we need to unroll it manually. \n O = torch.zeros(lseq, nseq, self.decoder.out_features)\n if self.recoder is None:\n emb = inp\n else:\n emb = self.recoder(inp)\n for t in range(lseq):\n if give_gates:\n out, hidden, ZR = self.rnn(emb[t:t+1,...], hidden, give_gates=True)\n Z[t,:,:] = ZR[0].squeeze(0).T\n R[t,:,:] = ZR[1].squeeze(0).T\n else:\n out, hidden = self.rnn(emb[t:t+1,...], hidden)\n dec = self.decoder(out)\n # naan = torch.ones(hidden.squeeze(0).shape)*np.nan\n # H[t,:,:] = torch.where(~ispad[t:t+1,:].T, hidden.squeeze(0), naan).T\n H[t,:,:] = hidden.squeeze(0).T\n O[t,:,:] = dec.squeeze(0)\n\n if give_gates:\n if debug:\n return O, H, Z, R, emb\n else:\n return O, H, Z, R\n else:\n if debug:\n return O, H, emb\n else:\n return O, H","def act(self, state):\n return","def forward_backward(self, x):\n observation_log_probs = self._observation_log_probs(x, mask=None)\n with tf.name_scope('forward_belief_propagation'):\n self.forward_log_probs = self._forward(observation_log_probs)\n\n with tf.name_scope('backward_belief_propagation'):\n self.backward_log_probs = self._backward(observation_log_probs)","def init_hidden_state(self, batch_size):\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\n return h, c","def init_hidden_state(self, batch_size):\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\n return h, c","def init_hidden_state(self, batch_size):\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\n return h, c","def _localSetState(self,pdict):\n super()._localSetState(pdict)\n self.transition = pdict.pop('transition')\n self.steadyStatePb = pdict.pop('steadyStatePb')","def is_hidden():\n return False","def is_hidden():\n return False","def forward(self):\n pass","def forward(self):\n pass","def transparent_forward(self, input, hidden, give_gates=False, debug=False):\n\n lseq, nseq = input.shape\n ispad = (input == self.padding)\n\n H = torch.zeros(lseq, self.nhid, nseq)\n if give_gates:\n Z = torch.zeros(lseq, self.nhid, nseq)\n R = torch.zeros(lseq, self.nhid, nseq)\n \n # because pytorch only returns hidden activity in the last time step,\n # we need to unroll it manually. \n O = torch.zeros(lseq, nseq, self.decoder.out_features)\n emb = self.encoder(input)\n for t in range(lseq):\n if give_gates:\n out, hidden, ZR = self.rnn(emb[t:t+1,...], hidden, give_gates=True)\n Z[t,:,:] = ZR[0].squeeze(0).T\n R[t,:,:] = ZR[1].squeeze(0).T\n else:\n out, hidden = self.rnn(emb[t:t+1,...], hidden)\n dec = self.decoder(out)\n # naan = torch.ones(hidden.squeeze(0).shape)*np.nan\n # H[t,:,:] = torch.where(~ispad[t:t+1,:].T, hidden.squeeze(0), naan).T\n H[t,:,:] = hidden.squeeze(0).T\n O[t,:,:] = dec.squeeze(0)\n\n if give_gates:\n if debug:\n return O, H, Z, R, emb\n else:\n return O, H, Z, R\n else:\n if debug:\n return O, H, emb\n else:\n return O, H","def hidden_singles(self):\n self.change = True\n while self.change:\n self.hidden_round()","def forward(self, input, hidden, give_gates=False, debug=False):\n\n emb = self.encoder(input)\n if emb.dim()<3:\n emb = emb.unsqueeze(0)\n\n if give_gates:\n output, hidden, extras = self.rnn(emb, hidden, give_gates)\n else:\n output, hidden = self.rnn(emb, hidden)\n\n # decoded = self.softmax(self.decoder(output))\n decoded = self.decoder(output)\n\n if give_gates:\n if debug:\n return decoded, hidden, extras, emb\n else:\n return decoded, hidden, extras\n else:\n if debug:\n return decoded, hidden, emb\n else:\n return decoded, hidden","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass"],"string":"[\n \"def _bridge_bidirectional_hidden(self, hidden):\\n num_layers = hidden.size(0) // 2\\n _, batch_size, hidden_size = hidden.size()\\n return hidden.view(num_layers, 2, batch_size, hidden_size)\\\\\\n .transpose(1, 2).contiguous().view(num_layers, batch_size, hidden_size * 2)\",\n \"def forward(self, states):\\n raise NotImplementedError()\",\n \"def init_hidden(self, batch_size):\\r\\n \\r\\n self.hidden_state = (\\r\\n torch.zeros(((1+self.bidirectional)*self.num_layers,\\r\\n batch_size,\\r\\n self.hidden_size)).to(self.device),\\r\\n torch.zeros(((1+self.bidirectional)*self.num_layers, \\r\\n batch_size, \\r\\n self.hidden_size)).to(self.device))\",\n \"def toggle_hidden(self):\\n AbstractChild.toggle_hidden(self)\\n self.accFrame.update_values()\\n self.botFrame.update_values()\\n # On toggle hidden\\n self.on_toggle_hidden()\",\n \"def hidden(self):\\n return self._hidden\",\n \"def forward(self, node_hidden, edge_hidden, adj_matrix, mask):\\n # x.shape = (batch, max_length, d_atom)\\n node_hidden = self.dropout(self.norm(node_hidden))\\n node_hidden_first, edge_hidden_temp = self.self_attn(node_hidden, node_hidden, edge_hidden, adj_matrix, mask)\\n # the first residue block\\n node_hidden_first = node_hidden + self.dropout(self.norm(node_hidden_first))\\n node_hidden_second = self.feed_forward(node_hidden_first)\\n # the second residue block\\n return node_hidden + node_hidden_first + self.dropout(self.norm(node_hidden_second)), edge_hidden\",\n \"def hidden(self, hidden):\\n\\n self._hidden = hidden\",\n \"def forward(self, input, states):\\n (hidden, cell) = states\\n\\n input = input + self.transform(hidden)\\n\\n forget_gate = torch.sigmoid(self.forget(input))\\n input_gate = torch.sigmoid(self.input(input))\\n output_gate = torch.sigmoid(self.output(input))\\n state_gate = torch.tanh(self.state(input))\\n\\n # Update internal cell state\\n cell = forget_gate * cell + input_gate * state_gate\\n hidden = output_gate * torch.tanh(cell)\\n\\n return hidden, cell\",\n \"def _transit_state(self) -> None:\\n pass\",\n \"def _TransformHidden(self, _):\\n raise NotImplementedError()\",\n \"def extract_hidden_states(self, output):\\n \\n # Extracting the forward and backward hidden states from the last BiLSTM layer\\n # output (batch_size, sequence length, 2 * hidden dim)\\n output_fw = output[:,:,0:self._hidden_size]\\n output_bw = output[:,:,self._hidden_size:]\\n \\n hidden_states = torch.cat((output_fw, output_bw),-1)\\n \\n return hidden_states\",\n \"def forward(self, input, hidden_states):\\n h, c = self.ih2h(input, hidden_states[0])\\n next_hiddens = [(h, c)]\\n h, c = self.h2h(h, hidden_states[1])\\n next_hiddens.append((h, c))\\n output = self.log_softmax(self.h2o(h))\\n return output, next_hiddens\",\n \"def forward(self, hidden: Union[torch.Tensor, Tuple[torch.Tensor, ...]]) -> Union[torch.Tensor, Tuple[torch.Tensor, ...]]:\\n # First, map the non-tuple version to a 1-tuple for easier processing.\\n # We will undo this at the end\\n if not isinstance(hidden, tuple):\\n hidden = (hidden,)\\n\\n batch_size, hidden_size = hidden[0].size()\\n\\n # If we are going to share parameters across the forward and backward\\n # directions, then we need to separate them in the tensors\\n if self.share_bidirectional_parameters:\\n # shape: (batch_size, 2, encoder_hidden_size // 2)\\n hidden = tuple(h.view(batch_size, 2, -1) for h in hidden)\\n\\n # Apply the bridge\\n output = tuple(layer(h) for layer, h in zip(self.layers, hidden))\\n\\n # Reshape the tensors if the parameters are shared\\n if self.share_bidirectional_parameters:\\n # shape: (batch_size, decoder_hidden_size)\\n output = tuple(h.view(batch_size, -1) for h in output)\\n\\n # Undo the tuple if there's only 1 element\\n if len(output) == 1:\\n output = output[0]\\n return output\",\n \"def hidden():\\n return False\",\n \"def forward(self, hidden_states):\\n # Common transformations (dense layer, layer norm + activation function) performed on text, KG and protein data\\n # transform is initialized in the parent BigBirdLMPredictionHead class\\n hidden_states = self.transform(hidden_states)\\n\\n # The first part is processed with the text decoder, the second with the entity decoder, and the third with the\\n # protein decoder to map to the text, kg, and protein vocab size, respectively\\n text_hidden_states_to_vocab = self.text_decoder(hidden_states[:, : self.kg_start_idx])\\n ent_hidden_states_to_kg_vocab = self.entity_decoder(\\n hidden_states[:, self.kg_start_idx : self.prot_start_idx]\\n )\\n prot_hidden_states_to_prot_vocab = self.prot_decoder(\\n hidden_states[:, self.prot_start_idx :]\\n )\\n\\n return (\\n text_hidden_states_to_vocab,\\n ent_hidden_states_to_kg_vocab,\\n prot_hidden_states_to_prot_vocab,\\n )\",\n \"def detach_hidden(self, zero=False):\\n if zero:\\n self.hidden = self._make_hidden(self.batch_size)\\n else:\\n self.hidden = self.hidden.detach()\",\n \"def init_hidden_state(self, encoder_out: torch.Tensor):\\n pass\",\n \"def forward(self, x, hidden):\\n emb_x = self.emb_layer(x)\\n lstm_out, hidden = self.lstm(emb_x, hidden)\\n if self.bidirectional:\\n # separate to forward and backward\\n # following code reshapes LSTM output to:\\n # (batch size, seq length, num directions, hidden dimensions)\\n # where direction '0' is forward and direction '1' is backward\\n lstm_out = lstm_out.contiguous().view(-1, self.seq_len, 2, self.hidden_dim)\\n # get backward output in first node\\n lstm_out_bw = lstm_out[:, 0, 1, :]\\n # get forward output in last node\\n lstm_out_fw = lstm_out[:, -1, 0, :]\\n # we may simple concatenate forward & backward outputs,\\n # or add them, multiply or average; in this case i used average\\n lstm_out = torch.add(input=lstm_out_bw, alpha=1, other=lstm_out_fw)\\n lstm_out = torch.div(lstm_out, 2)\\n else:\\n lstm_out = lstm_out[:, -1]\\n \\n assert lstm_out.shape[-1] == self.hidden_dim, (lstm_out.shape, self.hidden_dim)\\n lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)\\n \\n d_out = self.dropout(lstm_out)\\n fc_out = self.output_layer(d_out)\\n sig_out = torch.sigmoid(fc_out)\\n \\n # return last sigmoid output and hidden state\\n return sig_out, hidden\",\n \"def test_switch_hidden1(self):\\n self.test_object.switch_hidden()\\n self.assertFalse(self.test_object.get_hidden())\",\n \"def forward(self, input, hidden, key=None):\\n for cell_id, cell in enumerate(self.cells):\\n hidden[cell_id] = cell(input, hidden[cell_id])\\n if not isinstance(hidden[cell_id], (list, tuple)):\\n hidden[cell_id] = [hidden[cell_id]]\\n input = hidden[cell_id][0]\\n\\n if key is not None:\\n logits = self.policies[key](hidden[-1][0])\\n values = self.values[key](hidden[-1][0])\\n return logits, values, hidden\\n\\n return hidden\",\n \"def hidden(self) -> Generator[None, None, None]:\\n if self._hidden_level == 0:\\n self.hide()\\n self._hidden_level += 1\\n try:\\n yield\\n finally:\\n self._hidden_level -= 1\\n if self._hidden_level == 0:\\n self.show()\",\n \"def toggle_hidden(self):\\n if self.hidden:\\n self.show()\\n else:\\n self.hide()\",\n \"def extract_hidden_states(self, output):\\n # Intermediate hidden states\\n output_fw_intermediate = output[:,:-1,0:self._hidden_size]\\n output_bw_intermediate = output[:,1:,self._hidden_size:] \\n \\n # Last hidden states\\n output_fw = output[:,-1,0:self._hidden_size]\\n output_bw = output[:,0,self._hidden_size:]\\n last_ht = torch.cat((output_fw, output_bw), -1)\\n \\n return last_ht, output_fw_intermediate, output_bw_intermediate\",\n \"def detach_hidden(self, zero=False):\\n if zero:\\n self.hidden = self._make_hidden(self.batch_size)\\n else:\\n self.hidden[0].detach()\",\n \"def test_switch_hidden2(self):\\n self.test_object.switch_hidden()\\n self.test_object.switch_hidden()\\n self.assertTrue(self.test_object.get_hidden())\",\n \"def forward(self, x):\\n x, self.hidden = self.gru(x, self.hidden)\\n self.detach_hidden()\\n x = self.dropout(x)\\n x = self.out(x)\\n return x\",\n \"def backward(self, dout):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n for l in range(len(self.layers)-1,-1,-1):\\n act_dout = self.activations[l].backward(dout)\\n dout = self.layers[l].backward(act_dout)\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return\",\n \"def _set_state_after_forward(self):\\n for chunk_id, chunk in self.client.chunk_list.generate_chunk():\\n if (\\n chunk.get_state() == ChunkState.HOLD\\n or chunk.get_state() == ChunkState.HOLD_AFTER_FWD\\n ):\\n chunk.set_unused()\\n self.client.set_all_tensors_state_in_chunk(chunk_id, TensorState.HOLD)\",\n \"def stabilize(self, hidden, num_iters=1):\\n for i in range(num_iters):\\n g_off, hidden = self.add_transit(old_hidden=hidden)\\n return g_off, hidden\",\n \"def propdown(self, hid):\\n pre_sigmoid_activation = \\\\\\n T.dot(hid, self.hidden_layer.W.T) + self.vbias\\n return [pre_sigmoid_activation, T.nnet.sigmoid(pre_sigmoid_activation)]\",\n \"def add_state_desires(self):\\n raise NotImplementedError()\",\n \"def init_hidden(self):\\n # TODO ========================\\n # initialize the hidden states to zero\\n\\n initial_hidden = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)\\n return initial_hidden # a parameter tensor of shape (self.num_layers, self.batch_size, self.hidden_size)\",\n \"def initialize_state(self):\\n super(InverseChain, self).initialize_state()\",\n \"def _init_state(self, encoder_hidden):\\n if encoder_hidden is None:\\n return None\\n if isinstance(encoder_hidden, tuple):\\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\\n else:\\n encoder_hidden = self._cat_directions(encoder_hidden)\\n return encoder_hidden\",\n \"def _init_state(self, encoder_hidden):\\n if encoder_hidden is None:\\n return None\\n if isinstance(encoder_hidden, tuple):\\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\\n else:\\n encoder_hidden = self._cat_directions(encoder_hidden)\\n return encoder_hidden\",\n \"def setIsolateHidden( self, state ):\\n self._isolatedHidden = state\\n \\n super(XNode, self).setVisible(self.isVisible())\",\n \"def gibbs_step(self, visible):\\n hidden_prob = self.probabilities_hidden(visible)\\n hidden_state = self.sample(hidden_prob)\\n visible_prob = self.probabilities_visible(hidden_state)\\n visible_state = visible_prob\\n return hidden_prob, hidden_state, visible_prob, visible_state\",\n \"def post_backward_generator(self):\\n pass\",\n \"def reset_hidden(self, hidden, reset_flags):\\n # detach it from history (pytorch mechanics)\\n if self.rnn_type in ['lstm', 'mylstm']:\\n h = Variable(hidden[0].data)\\n c = Variable(hidden[1].data)\\n hidden = (h, c)\\n for b, flag in enumerate(reset_flags):\\n if flag.data[0] == 1: # data[0] access the data in Variable\\n hidden[0][:, b, :].data.fill_(0)\\n hidden[1][:, b, :].data.fill_(0)\\n elif self.rnn_type == 'gru':\\n hidden = Variable(hidden.data)\\n for b, flag in enumerate(reset_flags):\\n if flag.data[0] == 1: # data[0] access the data in Variable\\n hidden[:, b, :].data.fill_(0)\\n else:\\n print(\\\"Not support this type yet.\\\")\\n exit(0)\\n return hidden\",\n \"def forward(self):\\n raise NotImplemented\",\n \"def forward(self):\\n raise NotImplemented\",\n \"def forward(self):\\n raise NotImplemented\",\n \"def forward(self, input, hidden):\\n combined = torch.cat((input, hidden), 1)\\n hidden = self.i2h(combined)\\n output = self.i2o(combined)\\n output = self.softmax(output)\\n return output, hidden\",\n \"def backward(self):\\n raise NotImplemented\",\n \"def backward(self):\\n raise NotImplemented\",\n \"def backward(self):\\n raise NotImplemented\",\n \"def hidden(self):\\n return self._hidden\",\n \"def forward(self, state):\\n x = self.nonlin(self.fc1(self.in_fn(state)))\\n x = self.drop_layer(x)\\n x = self.nonlin(self.fc2(x))\\n x = self.drop_layer(x)\\n return self.fc3(x)\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def backward(self):\\n raise NotImplementedError\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def forward(self, inp, state):\\n emb = self.drop(self.encoder(inp))\\n y, state_next = self.rnn(emb, state)\\n y = self.drop(y)\\n y = self.decoder(y)\\n return y, state_next\",\n \"def flip(self):\",\n \"def forward(self, state):\\n x = self.conv(state).view(-1, self.hid_size)\\n x = self.fc1(x)\\n x = F.relu(x)\\n return self.fc2(x)\",\n \"def is_hidden(self):\\n return self.has_label(HIDDEN_LABEL)\",\n \"def forward_pass(self):\",\n \"def toggle(self) -> None:\",\n \"def toggle(self) -> None:\",\n \"def hidden(self) -> bool:\\n return False\",\n \"def hidden(self) -> bool:\\n return False\",\n \"def init_hidden(self, batch_size, device):\\n if self.mode == 'LSTM':\\n return (torch.ones((1+self.bidirectional , batch_size, self.hidden_dim), device=device),\\n torch.ones((1+self.bidirectional, batch_size, self.hidden_dim), device=device))\\n else:\\n return torch.ones((1+self.bidirectional, batch_size, self.hidden_dim), device=device)\",\n \"def post_backward_discriminator(self):\\n pass\",\n \"def forward_step(self, layer: int, hidden: AmbiguousHidden, input_: Tensor) -> AmbiguousHidden:\\n hx, cx = hidden\\n\\n # Forget gate\\n f_g = torch.sigmoid(self.gates[layer]['if'](input_) + self.gates[layer]['hf'](hx))\\n\\n # Input gate\\n i_g = torch.sigmoid(self.gates[layer]['ii'](input_) + self.gates[layer]['hi'](hx))\\n\\n # Output gate\\n o_g = torch.sigmoid(self.gates[layer]['io'](input_) + self.gates[layer]['ho'](hx))\\n\\n # Intermediate cell state\\n c_tilde_g = torch.tanh(self.gates[layer]['ig'](input_) + self.gates[layer]['hg'](hx))\\n\\n # New cell state\\n cx = f_g * cx + i_g * c_tilde_g\\n\\n # New hidden state\\n hx = o_g * torch.tanh(cx)\\n\\n return hx, cx\",\n \"def toggle(self):\",\n \"def init_hidden_state(self,batch_size):\\n h = torch.zeros(batch_size,self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size,self.decoder_dim).to(device)\\n return h, c\",\n \"def backward(self, top, propagate_down, bottom):\\n\\t\\tpass\",\n \"def flip_state(self):\\n logging.debug(\\\"element selected\\\")\\n if len(self._contents) == 0:\\n self.deactivate()\\n else:\\n if self._contents[self.pointer][2] == 'exit':\\n self.deactivate()\\n return\\n self.states[self.pointer] = not self.states[self.pointer] #Just inverting.\\n self.refresh()\",\n \"def toggle_hidden(self):\\n self.show_hidden = not self.show_hidden\\n self.reload('.')\",\n \"def _repackage(self):\\n self.hidden = _var(self.hidden.data)\\n if self.G.ntype == \\\"lstm\\\":\\n self.state = _var(self.state.data)\",\n \"def forward(self, input, hidden):\\r\\n output, hidden = self.rnn(input, hidden)\\r\\n output = f.log_softmax(self.out(output.squeeze(1)), 1)\\r\\n return output, hidden\",\n \"def hidden(self, value):\\n if value is not None:\\n value.get_shape().assert_is_compatible_with(self._output_shape)\\n self._hidden = value\",\n \"def forward(self, x, hidden):\\n batch_size=x.shape[0]\\n\\n x = self.embed(x)\\n\\n x,hidden = self.lstm(x,hidden)\\n\\n x = x.reshape(-1,self.hidden_dim)\\n\\n x = self.drp(x)\\n\\n x = self.fc(x)\\n\\n sig_out = self.sigmoid(x)\\n\\n # return last sigmoid output and hidden state\\n sig_out = sig_out.reshape(batch_size,-1)\\n sig_out = sig_out[:,-1]\\n\\n return sig_out, hidden\",\n \"def forward_backward(observations):\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE GOES HERE\\n #\\n # observations = [(4, 3), (4, 2), (3, 2), (4, 0), (2, 0), (2, 0), (3, 2), \\n # (4, 2), (2, 3), (3, 5)]\\n num_time_steps = len(observations)\\n forward_messages = [None] * num_time_steps\\n forward_messages[0] = prior_matrix\\n # # # TODO: Compute the forward messages\\n for i,x_i in enumerate(observations):\\n if x_i:\\n obs_index = obs_state_index_map[x_i]\\n pi_0 = forward_messages[i]\\n # print(len(B[:obs_index]))\\n weights = np.multiply(pi_0, B[:,obs_index])\\n # x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\\n else:\\n weights = forward_messages[i]\\n # print(weights)\\n x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\\n if i+1 < len(forward_messages):\\n forward_messages[i+1] = x#normalize(x)\\n # break\\n\\n ## forward messages as dictionary\\n # for_dict = [None]*num_time_steps\\n # for j,f in enumerate(forward_messages):\\n # x = Distribution()\\n # for i,x_i in enumerate(f):\\n # if x_i == 0:\\n # continue\\n # # print(i,x_i)\\n # x[all_possible_hidden_states[i]] = x_i\\n # for_dict[j] = x.renormalize()\\n # print(for_dict[3])\\n\\n # print('--------------\\\\n-----------------\\\\n')\\n\\n\\n backward_messages = [None] * num_time_steps\\n # backward_messages[-1] = [1]*len(prior_matrix)\\n message = np.ones(len(all_possible_hidden_states), dtype=np.float64)\\n backward_messages[-1] = message/len(all_possible_hidden_states)\\n \\n# ****\\n ## Backwards messages\\n for i,x_i in enumerate(reversed(observations)):\\n # print(x_i)\\n if x_i:\\n obs_index = obs_state_index_map[x_i]\\n pi = backward_messages[-1-i]\\n weights = np.multiply(pi, B[:,obs_index])\\n else:\\n weights = backward_messages[-1-i]\\n # print(i)\\n x = sum([A[:,j]*w_i for j,w_i in enumerate(weights)])\\n\\n if i+1 < len(backward_messages):\\n backward_messages[-2-i] = x#normalize(x)\\n\\n ## backward messages as dictionary\\n # back_dict = [None]*num_time_steps\\n # for j,b in enumerate(backward_messages):\\n # x = Distribution()\\n # if b == None:\\n # continue\\n # for i,x_i in enumerate(b):\\n # if x_i == 0 or x_i==None:\\n # continue\\n # # print(i,x_i)\\n # x[all_possible_hidden_states[i]] = x_i\\n # back_dict[j] = x.renormalize()\\n \\n # print(back_dict[0])\\n # print(A[:10,:10])\\n # print('\\\\n-----------------\\\\n', B[:10,:10])\\n\\n # print(backward_messages[2])\\n # backward_messages[0] = forward_messages[0]\\n # # ## marginals as matrix\\n marginals = [None] * num_time_steps \\n for i,x_i in enumerate(observations):\\n if x_i:\\n obs_index = obs_state_index_map[x_i]\\n marginals[i] = np.multiply(np.multiply(backward_messages[i],\\n forward_messages[i]),\\n B[:,obs_index])\\n else:\\n marginals[i] = np.multiply(backward_messages[i],forward_messages[i])\\n # if i == 0:\\n # marginals[i] = np.multiply(backward_messages[i], B[:,obs_index])\\n # elif i == len(observations)-1:\\n # marginals[i] = np.multiply(forward_messages[i], B[:,obs_index])\\n # else:\\n\\n ## marginals as dictionary\\n marg_dict = [None]*num_time_steps\\n for j,m in enumerate(marginals):\\n x = Distribution()\\n for i,x_i in enumerate(m):\\n if x_i == 0 or x_i==None:\\n continue\\n x[all_possible_hidden_states[i]] = x_i\\n marg_dict[j] = x.renormalize()\\n # print(marginals[i])\\n # print(A[:10, :10], '\\\\n')\\n # print(B[:10, :10], '\\\\n')\\n # print(marg_dict)\\n return marg_dict\",\n \"def detach_hidden(hidden: Any) -> Any:\\n return apply_to_tensor(hidden, Tensor.detach)\",\n \"def hidden_layers(self):\\n\\t\\tif self.hidden is None:\\n\\t\\t\\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\\n\\t\\t\\tlast_hidden = self.x\\n\\t\\t\\tif self.covnet == 1:\\n\\t\\t\\t\\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\\n\\t\\t\\telif self.covnet == 2:\\n\\t\\t\\t\\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\\n\\t\\t\\t\\t self.layerSize[0], self.layerSize[1])\\n\\t\\t\\telse:\\n\\n\\t\\t\\t\\tself._drouput = 'dr'\\n\\t\\t\\t\\t# self.hidden.append(self.x)\\n\\t\\t\\t\\tfor i in range(1, len(self.all_layer_sizes)):\\n\\t\\t\\t\\t\\tname_scope = 'hidden' + str(i - 1)\\n\\t\\t\\t\\t\\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\\n\\t\\t\\t\\t\\tactivation_function = self.activation_function\\n\\t\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\\n\\t\\t\\t\\t\\t last_hidden)\\n\\t\\t\\t\\tname_scope = 'final_layer'\\n\\t\\t\\t\\trow_size, col_size = self.layerSize[-1], self.num_of_classes\\n\\t\\t\\t\\tactivation_function = None\\n\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\\n\\t\\treturn self.hidden\",\n \"def backward(self, top, propagate_down, bottom):\\r\\n pass\",\n \"def init_hidden(self):\\n pass\",\n \"def init_hidden(self):\\n pass\",\n \"def _hidden_activation(self, inputs):\\n if self.act_enc is None:\\n act_enc = lambda x: x\\n else:\\n act_enc = self.act_enc\\n return act_enc(self._mappings(inputs))\",\n \"def forward(self)->None:\",\n \"def transparent_forward(self, inp, hidden=None, give_gates=False, debug=False):\\n\\n lseq = inp.shape[0]\\n nseq = inp.shape[1]\\n # ispad = (input == self.padding)\\n\\n if hidden is None:\\n hidden = self.init_hidden(nseq)\\n\\n H = torch.zeros(lseq, self.nhid, nseq)\\n if give_gates:\\n Z = torch.zeros(lseq, self.nhid, nseq)\\n R = torch.zeros(lseq, self.nhid, nseq)\\n \\n # because pytorch only returns hidden activity in the last time step,\\n # we need to unroll it manually. \\n O = torch.zeros(lseq, nseq, self.decoder.out_features)\\n if self.recoder is None:\\n emb = inp\\n else:\\n emb = self.recoder(inp)\\n for t in range(lseq):\\n if give_gates:\\n out, hidden, ZR = self.rnn(emb[t:t+1,...], hidden, give_gates=True)\\n Z[t,:,:] = ZR[0].squeeze(0).T\\n R[t,:,:] = ZR[1].squeeze(0).T\\n else:\\n out, hidden = self.rnn(emb[t:t+1,...], hidden)\\n dec = self.decoder(out)\\n # naan = torch.ones(hidden.squeeze(0).shape)*np.nan\\n # H[t,:,:] = torch.where(~ispad[t:t+1,:].T, hidden.squeeze(0), naan).T\\n H[t,:,:] = hidden.squeeze(0).T\\n O[t,:,:] = dec.squeeze(0)\\n\\n if give_gates:\\n if debug:\\n return O, H, Z, R, emb\\n else:\\n return O, H, Z, R\\n else:\\n if debug:\\n return O, H, emb\\n else:\\n return O, H\",\n \"def act(self, state):\\n return\",\n \"def forward_backward(self, x):\\n observation_log_probs = self._observation_log_probs(x, mask=None)\\n with tf.name_scope('forward_belief_propagation'):\\n self.forward_log_probs = self._forward(observation_log_probs)\\n\\n with tf.name_scope('backward_belief_propagation'):\\n self.backward_log_probs = self._backward(observation_log_probs)\",\n \"def init_hidden_state(self, batch_size):\\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\\n return h, c\",\n \"def init_hidden_state(self, batch_size):\\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\\n return h, c\",\n \"def init_hidden_state(self, batch_size):\\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\\n return h, c\",\n \"def _localSetState(self,pdict):\\n super()._localSetState(pdict)\\n self.transition = pdict.pop('transition')\\n self.steadyStatePb = pdict.pop('steadyStatePb')\",\n \"def is_hidden():\\n return False\",\n \"def is_hidden():\\n return False\",\n \"def forward(self):\\n pass\",\n \"def forward(self):\\n pass\",\n \"def transparent_forward(self, input, hidden, give_gates=False, debug=False):\\n\\n lseq, nseq = input.shape\\n ispad = (input == self.padding)\\n\\n H = torch.zeros(lseq, self.nhid, nseq)\\n if give_gates:\\n Z = torch.zeros(lseq, self.nhid, nseq)\\n R = torch.zeros(lseq, self.nhid, nseq)\\n \\n # because pytorch only returns hidden activity in the last time step,\\n # we need to unroll it manually. \\n O = torch.zeros(lseq, nseq, self.decoder.out_features)\\n emb = self.encoder(input)\\n for t in range(lseq):\\n if give_gates:\\n out, hidden, ZR = self.rnn(emb[t:t+1,...], hidden, give_gates=True)\\n Z[t,:,:] = ZR[0].squeeze(0).T\\n R[t,:,:] = ZR[1].squeeze(0).T\\n else:\\n out, hidden = self.rnn(emb[t:t+1,...], hidden)\\n dec = self.decoder(out)\\n # naan = torch.ones(hidden.squeeze(0).shape)*np.nan\\n # H[t,:,:] = torch.where(~ispad[t:t+1,:].T, hidden.squeeze(0), naan).T\\n H[t,:,:] = hidden.squeeze(0).T\\n O[t,:,:] = dec.squeeze(0)\\n\\n if give_gates:\\n if debug:\\n return O, H, Z, R, emb\\n else:\\n return O, H, Z, R\\n else:\\n if debug:\\n return O, H, emb\\n else:\\n return O, H\",\n \"def hidden_singles(self):\\n self.change = True\\n while self.change:\\n self.hidden_round()\",\n \"def forward(self, input, hidden, give_gates=False, debug=False):\\n\\n emb = self.encoder(input)\\n if emb.dim()<3:\\n emb = emb.unsqueeze(0)\\n\\n if give_gates:\\n output, hidden, extras = self.rnn(emb, hidden, give_gates)\\n else:\\n output, hidden = self.rnn(emb, hidden)\\n\\n # decoded = self.softmax(self.decoder(output))\\n decoded = self.decoder(output)\\n\\n if give_gates:\\n if debug:\\n return decoded, hidden, extras, emb\\n else:\\n return decoded, hidden, extras\\n else:\\n if debug:\\n return decoded, hidden, emb\\n else:\\n return decoded, hidden\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69670856","0.6397652","0.6265983","0.6238433","0.61677355","0.61020136","0.60459715","0.60427034","0.6039696","0.5999765","0.5988221","0.598384","0.5973033","0.5929639","0.591734","0.5909836","0.5899876","0.58930695","0.58797956","0.5878488","0.58754236","0.58631843","0.5860396","0.582561","0.5799732","0.5798763","0.57897353","0.57803786","0.57696754","0.5754079","0.5748362","0.573542","0.57326186","0.57233113","0.57233113","0.5717261","0.57026607","0.56961185","0.56830674","0.5682909","0.5682909","0.5682909","0.568004","0.567124","0.567124","0.567124","0.56624454","0.5661189","0.56564456","0.56564456","0.5640877","0.56370497","0.56370497","0.56312674","0.56237006","0.56036174","0.5599706","0.55877066","0.5586992","0.5586992","0.558346","0.558346","0.55697644","0.55647093","0.55638045","0.555131","0.5547849","0.5546529","0.5543302","0.55420804","0.5530079","0.55295277","0.552323","0.5521589","0.5514112","0.55045307","0.5504523","0.548357","0.54756135","0.54756135","0.5467778","0.5466713","0.54649705","0.5463738","0.54610234","0.5453371","0.5453371","0.5453371","0.5450528","0.5444168","0.5444168","0.54365706","0.54365706","0.54345405","0.5418065","0.54128385","0.5411881","0.5411881","0.5411881","0.5411881","0.5411881"],"string":"[\n \"0.69670856\",\n \"0.6397652\",\n \"0.6265983\",\n \"0.6238433\",\n \"0.61677355\",\n \"0.61020136\",\n \"0.60459715\",\n \"0.60427034\",\n \"0.6039696\",\n \"0.5999765\",\n \"0.5988221\",\n \"0.598384\",\n \"0.5973033\",\n \"0.5929639\",\n \"0.591734\",\n \"0.5909836\",\n \"0.5899876\",\n \"0.58930695\",\n \"0.58797956\",\n \"0.5878488\",\n \"0.58754236\",\n \"0.58631843\",\n \"0.5860396\",\n \"0.582561\",\n \"0.5799732\",\n \"0.5798763\",\n \"0.57897353\",\n \"0.57803786\",\n \"0.57696754\",\n \"0.5754079\",\n \"0.5748362\",\n \"0.573542\",\n \"0.57326186\",\n \"0.57233113\",\n \"0.57233113\",\n \"0.5717261\",\n \"0.57026607\",\n \"0.56961185\",\n \"0.56830674\",\n \"0.5682909\",\n \"0.5682909\",\n \"0.5682909\",\n \"0.568004\",\n \"0.567124\",\n \"0.567124\",\n \"0.567124\",\n \"0.56624454\",\n \"0.5661189\",\n \"0.56564456\",\n \"0.56564456\",\n \"0.5640877\",\n \"0.56370497\",\n \"0.56370497\",\n \"0.56312674\",\n \"0.56237006\",\n \"0.56036174\",\n \"0.5599706\",\n \"0.55877066\",\n \"0.5586992\",\n \"0.5586992\",\n \"0.558346\",\n \"0.558346\",\n \"0.55697644\",\n \"0.55647093\",\n \"0.55638045\",\n \"0.555131\",\n \"0.5547849\",\n \"0.5546529\",\n \"0.5543302\",\n \"0.55420804\",\n \"0.5530079\",\n \"0.55295277\",\n \"0.552323\",\n \"0.5521589\",\n \"0.5514112\",\n \"0.55045307\",\n \"0.5504523\",\n \"0.548357\",\n \"0.54756135\",\n \"0.54756135\",\n \"0.5467778\",\n \"0.5466713\",\n \"0.54649705\",\n \"0.5463738\",\n \"0.54610234\",\n \"0.5453371\",\n \"0.5453371\",\n \"0.5453371\",\n \"0.5450528\",\n \"0.5444168\",\n \"0.5444168\",\n \"0.54365706\",\n \"0.54365706\",\n \"0.54345405\",\n \"0.5418065\",\n \"0.54128385\",\n \"0.5411881\",\n \"0.5411881\",\n \"0.5411881\",\n \"0.5411881\",\n \"0.5411881\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":82997,"cells":{"query":{"kind":"string","value":"Extracts last hidden states from both directions."},"document":{"kind":"string","value":"def extract_hidden_states(self, output):\n \n # Extracting the forward and backward hidden states from the last BiLSTM layer\n # output (batch_size, sequence length, 2 * hidden dim)\n output_fw = output[:,:,0:self._hidden_size]\n output_bw = output[:,:,self._hidden_size:]\n \n hidden_states = torch.cat((output_fw, output_bw),-1)\n \n return hidden_states"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def extract_hidden_states(self, output):\n # Intermediate hidden states\n output_fw_intermediate = output[:,:-1,0:self._hidden_size]\n output_bw_intermediate = output[:,1:,self._hidden_size:] \n \n # Last hidden states\n output_fw = output[:,-1,0:self._hidden_size]\n output_bw = output[:,0,self._hidden_size:]\n last_ht = torch.cat((output_fw, output_bw), -1)\n \n return last_ht, output_fw_intermediate, output_bw_intermediate","def extract_last_hidden_state(hidden_state):\n seq_len, hidden_size = hidden_state.size()\n assert hidden_size % 2 == 0\n split_point = hidden_size // 2\n last_hidden_state = torch.cat(\n [hidden_state[-1, :split_point], hidden_state[0, split_point:]], dim=0\n )\n return last_hidden_state","def extract_last_hidden_state_batched(hidden_state, lengths, bidirectional):\n bs, seq_len, hidden_size = hidden_state.size()\n assert bs == len(lengths)\n assert hidden_size % 2 == 0\n split_point = hidden_size // 2\n\n length_v = torch.stack(lengths, dim=0)\n if bidirectional:\n last_idx = (length_v - 1).unsqueeze(-1).unsqueeze(-1).expand(bs, 1, split_point)\n first_idx = torch.zeros([bs, 1, split_point], dtype=torch.long)\n batched_idx = torch.cat([last_idx, first_idx], dim=-1).to(hidden_state.device)\n last_hidden_state = torch.gather(\n hidden_state, dim=1, index=batched_idx\n ).squeeze(1)\n else:\n last_idx = (\n (length_v - 1)\n .unsqueeze(-1)\n .unsqueeze(-1)\n .expand(bs, 1, hidden_size)\n .to(hidden_state.device)\n )\n last_hidden_state = torch.gather(hidden_state, dim=1, index=last_idx).squeeze(1)\n\n return last_hidden_state","def get_last_hidden(docs, drop=0.0):\n outputs = [doc._.get(ATTRS.last_hidden_state) for doc in docs]\n for out in outputs:\n assert out is not None\n assert out.size != 0\n\n def backprop_last_hidden(d_outputs, sgd=None):\n for doc, d_lh in zip(docs, d_outputs):\n xp = get_array_module(d_lh)\n shape = d_lh.shape\n dtype = d_lh.dtype\n if doc._.get(ATTRS.d_last_hidden_state).size == 0:\n doc._.set(ATTRS.d_last_hidden_state, xp.zeros(shape, dtype=dtype))\n doc._.set(\n ATTRS.d_last_hidden_state, doc._.get(ATTRS.d_last_hidden_state) + d_lh\n )\n return None\n\n return outputs, backprop_last_hidden","def neighboring_states(self):\n index = self.state.index(0)\n\n if index == 0:\n return [self.move(movement) for movement in ['down', 'right']]\n elif index == 1:\n return [self.move(movement) for movement in ['down', 'left', 'right']]\n elif index == 2:\n return [self.move(movement) for movement in ['down', 'left']]\n elif index == 3:\n return [self.move(movement) for movement in ['up', 'down', 'right']]\n elif index == 4:\n return [self.move(movement) for movement in ['up', 'down', 'left', 'right']]\n elif index == 5:\n return [self.move(movement) for movement in ['up', 'down', 'left']]\n elif index == 6:\n return [self.move(movement) for movement in ['up', 'right']]\n elif index == 7:\n return [self.move(movement) for movement in ['up', 'left', 'right']]\n else:\n # index == 8\n return [self.move(movement) for movement in ['up', 'left']]","def get_latest_states(self) -> Tuple:\n # Ensure index is in an allowable range\n assert self.step <= self.num_steps\n\n o_t = self.obs_buffer[self.step].unsqueeze(0)\n h_tminus1 = self.hid_buffer[self.step].unsqueeze(0)\n m_t = self.don_buffer[self.step].unsqueeze(0)\n\n return o_t, h_tminus1, m_t","def next_states(self):\n return self._states[1:]","def final_states(self) -> Tuple[tuple, ...]:\n return self._final_states","def get_output_states(self):\n return self.states[-self.num_output_states:]","def find_dark_states(excited_state, ground_states):","def get_rnn_hidden_state(h):\n return h if not isinstance(h, tuple) else h[0]","def iter_final_states(self):\n from six.moves import filter\n return filter(lambda s:s.is_final, self.iter_states())","def get_previous_nodes_states(self, n):\n return self.simulation_output[-n - 1]","def extract_lstm_minus_feature(hidden_state, i, j):\n seq_len, bs, hidden_size = hidden_state.size()\n assert hidden_size % 2 == 0\n split_point = hidden_size // 2\n hidden_f = hidden_state[j + 1, :, :split_point] - hidden_state[i, :, :split_point]\n hidden_b = (\n hidden_state[i + 1, :, split_point:] - hidden_state[j + 2, :, split_point:]\n )\n span_v = torch.cat([hidden_f, hidden_b], dim=-1)\n return span_v","def final_states(self):\n return list(self.iter_final_states())","def get_states():\n # Getting all hidden state through time\n all_hidden_states = tf.scan(GRU, processed_input, \n initializer=initial_hidden, name='states')\n return all_hidden_states","def _backtrack(self, nw_output, nw_hidden, predecessors, symbols, scores, b, hidden_size):\n\n lstm = isinstance(nw_hidden[0], tuple)\n\n # initialize return variables given different types\n output = list()\n h_t = list()\n p = list()\n # Placeholder for last hidden state of top-k sequences.\n # If a (top-k) sequence ends early in decoding, `h_n` contains\n # its hidden state when it sees EOS. Otherwise, `h_n` contains\n # the last hidden state of decoding.\n if lstm:\n state_size = nw_hidden[0][0].size()\n h_n = tuple([torch.zeros(state_size).to(device), torch.zeros(state_size).to(device)])\n else:\n h_n = torch.zeros(nw_hidden[0].size()).to(device)\n l = [[self.max_length] * self.k for _ in range(b)] # Placeholder for lengths of top-k sequences\n # Similar to `h_n`\n\n # the last step output of the beams are not sorted\n # thus they are sorted here\n sorted_score, sorted_idx = scores[-1].view(b, self.k).topk(self.k)\n # initialize the sequence scores with the sorted last step beam scores\n s = sorted_score.clone()\n\n batch_eos_found = [0] * b # the number of EOS found\n # in the backward loop below for each batch\n\n t = self.max_length - 1\n # initialize the back pointer with the sorted order of the last step beams.\n # add self.pos_index for indexing variable with b*k as the first dimension.\n t_predecessors = (sorted_idx + self.pos_index.expand_as(sorted_idx)).view(b * self.k)\n while t >= 0:\n # Re-order the variables with the back pointer\n current_output = nw_output[t].index_select(0, t_predecessors)\n if lstm:\n current_hidden = tuple([h.index_select(1, t_predecessors) for h in nw_hidden[t]])\n else:\n current_hidden = nw_hidden[t].index_select(1, t_predecessors)\n current_symbol = symbols[t].index_select(0, t_predecessors)\n # Re-order the back pointer of the previous step with the back pointer of\n # the current step\n t_predecessors = predecessors[t].index_select(0, t_predecessors).squeeze()\n\n # This tricky block handles dropped sequences that see EOS earlier.\n # The basic idea is summarized below:\n #\n # Terms:\n # Ended sequences = sequences that see EOS early and dropped\n # Survived sequences = sequences in the last step of the beams\n #\n # Although the ended sequences are dropped during decoding,\n # their generated symbols and complete backtracking information are still\n # in the backtracking variables.\n # For each batch, everytime we see an EOS in the backtracking process,\n # 1. If there is survived sequences in the return variables, replace\n # the one with the lowest survived sequence score with the new ended\n # sequences\n # 2. Otherwise, replace the ended sequence with the lowest sequence\n # score with the new ended sequence\n #\n eos_indices = symbols[t].data.squeeze(1).eq(self.EOS).nonzero()\n if eos_indices.dim() > 0:\n for i in range(eos_indices.size(0) - 1, -1, -1):\n # Indices of the EOS symbol for both variables\n # with b*k as the first dimension, and b, k for\n # the first two dimensions\n idx = eos_indices[i]\n b_idx = int(idx[0] // self.k)\n # The indices of the replacing position\n # according to the replacement strategy noted above\n res_k_idx = self.k - (batch_eos_found[b_idx] % self.k) - 1\n batch_eos_found[b_idx] += 1\n res_idx = b_idx * self.k + res_k_idx\n\n # Replace the old information in return variables\n # with the new ended sequence information\n t_predecessors[res_idx] = predecessors[t][idx[0]]\n current_output[res_idx, :] = nw_output[t][idx[0], :]\n if lstm:\n current_hidden[0][:, res_idx, :] = nw_hidden[t][0][:, idx[0], :]\n current_hidden[1][:, res_idx, :] = nw_hidden[t][1][:, idx[0], :]\n h_n[0][:, res_idx, :] = nw_hidden[t][0][:, idx[0], :].data\n h_n[1][:, res_idx, :] = nw_hidden[t][1][:, idx[0], :].data\n else:\n current_hidden[:, res_idx, :] = nw_hidden[t][:, idx[0], :]\n h_n[:, res_idx, :] = nw_hidden[t][:, idx[0], :].data\n current_symbol[res_idx, :] = symbols[t][idx[0]]\n s[b_idx, res_k_idx] = scores[t][idx[0]].data[0]\n l[b_idx][res_k_idx] = t + 1\n\n # record the back tracked results\n output.append(current_output)\n h_t.append(current_hidden)\n p.append(current_symbol)\n\n t -= 1\n\n # Sort and re-order again as the added ended sequences may change\n # the order (very unlikely)\n s, re_sorted_idx = s.topk(self.k)\n for b_idx in range(b):\n l[b_idx] = [l[b_idx][k_idx.item()] for k_idx in re_sorted_idx[b_idx, :]]\n\n re_sorted_idx = (re_sorted_idx + self.pos_index.expand_as(re_sorted_idx)).view(b * self.k)\n\n # Reverse the sequences and re-order at the same time\n # It is reversed because the backtracking happens in reverse time order\n output = [step.index_select(0, re_sorted_idx).view(b, self.k, -1) for step in reversed(output)]\n p = [step.index_select(0, re_sorted_idx).view(b, self.k, -1) for step in reversed(p)]\n if lstm:\n h_t = [tuple([h.index_select(1, re_sorted_idx).view(-1, b, self.k, hidden_size) for h in step]) for step in reversed(h_t)]\n h_n = tuple([h.index_select(1, re_sorted_idx.data).view(-1, b, self.k, hidden_size) for h in h_n])\n else:\n h_t = [step.index_select(1, re_sorted_idx).view(-1, b, self.k, hidden_size) for step in reversed(h_t)]\n h_n = h_n.index_select(1, re_sorted_idx.data).view(-1, b, self.k, hidden_size)\n s = s.data\n\n return output, h_t, h_n, s, l, p","def _extract_states(self, state):\n conf = self._config\n\n # c_prev is `m` (cell value), and\n # m_prev is `h` (previous output) in the paper.\n # Keeping c and m here for consistency with the codebase\n c_prev = [None] * conf.num_dims\n m_prev = [None] * conf.num_dims\n\n # for LSTM : state = memory cell + output, hence cell_output_size > 0\n # for GRU/RNN: state = output (whose size is equal to _num_units),\n # hence cell_output_size = 0\n total_cell_state_size = self._cell_state_size()\n cell_output_size = total_cell_state_size - conf.num_units\n\n if self._state_is_tuple:\n if len(conf.recurrents) != len(state):\n raise ValueError('Expected state as a tuple of {} '\n 'element'.format(len(conf.recurrents)))\n\n for recurrent_dim, recurrent_state in zip(conf.recurrents, state):\n if cell_output_size > 0:\n c_prev[recurrent_dim], m_prev[recurrent_dim] = recurrent_state\n else:\n m_prev[recurrent_dim] = recurrent_state\n else:\n for recurrent_dim, start_idx in zip(conf.recurrents,\n range(0, self.state_size,\n total_cell_state_size)):\n if cell_output_size > 0:\n c_prev[recurrent_dim] = array_ops.slice(state, [0, start_idx],\n [-1, conf.num_units])\n m_prev[recurrent_dim] = array_ops.slice(\n state, [0, start_idx + conf.num_units], [-1, cell_output_size])\n else:\n m_prev[recurrent_dim] = array_ops.slice(state, [0, start_idx],\n [-1, conf.num_units])\n return c_prev, m_prev, cell_output_size","def get_final_state(self):\n state = {}\n s = self.copy()\n clip = not np.isscalar(self['t'])\n if clip:\n # only get results for the last timepoint\n s.set_state(self.state[:, -1])\n \n for k in self.difeq_vars:\n state[k] = s[k]\n for k in self.dep_vars:\n state[k] = s[k]\n for k,v in self.extra.items():\n if clip:\n state[k] = v[-1]\n else:\n state[k] = v\n \n return state","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def remove_initial_hidden_if_possible(net, im):\n source = list(im.keys())[0]\n first_hidden = list(source.out_arcs)[0].target\n target_places_first_hidden = [x.target for x in first_hidden.out_arcs]\n if len(target_places_first_hidden) == 1:\n target_place_first_hidden = target_places_first_hidden[0]\n if len(target_place_first_hidden.in_arcs) == 1:\n new_im = Marking()\n new_im[target_place_first_hidden] = 1\n remove_place(net, source)\n remove_transition(net, first_hidden)\n return net, new_im\n return net, im","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def Get_States(self):\n\n # Getting all hidden state throuh time\n all_hidden_states = tf.scan(self.LSTM,\n self.processed_input,\n initializer=self.initial_hidden,\n name='states')\n all_hidden_states=all_hidden_states[:,0,:,:]\n \n return all_hidden_states","def get_final_states(self):\r\n return set(self.final_states)","def stabilize(self, hidden, num_iters=1):\n for i in range(num_iters):\n g_off, hidden = self.add_transit(old_hidden=hidden)\n return g_off, hidden","def hidden_layers(self):\n\t\tif self.hidden is None:\n\t\t\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\n\t\t\tlast_hidden = self.x\n\t\t\tif self.covnet == 1:\n\t\t\t\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\n\t\t\telif self.covnet == 2:\n\t\t\t\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\n\t\t\t\t self.layerSize[0], self.layerSize[1])\n\t\t\telse:\n\n\t\t\t\tself._drouput = 'dr'\n\t\t\t\t# self.hidden.append(self.x)\n\t\t\t\tfor i in range(1, len(self.all_layer_sizes)):\n\t\t\t\t\tname_scope = 'hidden' + str(i - 1)\n\t\t\t\t\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\n\t\t\t\t\tactivation_function = self.activation_function\n\t\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\n\t\t\t\t\t last_hidden)\n\t\t\t\tname_scope = 'final_layer'\n\t\t\t\trow_size, col_size = self.layerSize[-1], self.num_of_classes\n\t\t\t\tactivation_function = None\n\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\n\t\treturn self.hidden","def get_final_encoder_states(encoder_outputs: torch.Tensor,\n mask: torch.Tensor,\n bidirectional: bool = False) -> torch.Tensor:\n # These are the indices of the last words in the sequences (i.e. length sans padding - 1). We\n # are assuming sequences are right padded.\n # Shape: (batch_size,)\n last_word_indices = mask.sum(1).long() - 1\n\n # handle -1 cases\n ll_ = (last_word_indices != -1).long()\n last_word_indices = last_word_indices * ll_\n\n batch_size, _, encoder_output_dim = encoder_outputs.size()\n expanded_indices = last_word_indices.view(-1, 1, 1).expand(batch_size, 1, encoder_output_dim)\n # Shape: (batch_size, 1, encoder_output_dim)\n final_encoder_output = encoder_outputs.gather(1, expanded_indices)\n final_encoder_output = final_encoder_output.squeeze(1) # (batch_size, encoder_output_dim)\n if bidirectional:\n final_forward_output = final_encoder_output[:, :(encoder_output_dim // 2)]\n final_backward_output = encoder_outputs[:, 0, (encoder_output_dim // 2):]\n final_encoder_output = torch.cat([final_forward_output, final_backward_output], dim=-1)\n return final_encoder_output","def mdp_state_neighbors(mdp, s):\n neigh = set()\n for a in mdp.actions(s):\n for s2 in mdp.transition(s, a):\n if not s == s2:\n neigh.add(s2)\n return neigh","def dec_step(prev_chars, dec_hidden):\n\n scores, dec_hidden = self.forward(prev_chars, dec_hidden)\n next_chars = scores.argmax(dim=-1)\n return next_chars, dec_hidden","def reset_hidden(self, hidden, reset_flags):\n # detach it from history (pytorch mechanics)\n if self.rnn_type in ['lstm', 'mylstm']:\n h = Variable(hidden[0].data)\n c = Variable(hidden[1].data)\n hidden = (h, c)\n for b, flag in enumerate(reset_flags):\n if flag.data[0] == 1: # data[0] access the data in Variable\n hidden[0][:, b, :].data.fill_(0)\n hidden[1][:, b, :].data.fill_(0)\n elif self.rnn_type == 'gru':\n hidden = Variable(hidden.data)\n for b, flag in enumerate(reset_flags):\n if flag.data[0] == 1: # data[0] access the data in Variable\n hidden[:, b, :].data.fill_(0)\n else:\n print(\"Not support this type yet.\")\n exit(0)\n return hidden","def init_hidden(self):\n # TODO ========================\n # initialize the hidden states to zero\n\n initial_hidden = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)\n return initial_hidden # a parameter tensor of shape (self.num_layers, self.batch_size, self.hidden_size)","def getNonFinalNextStateBatch(mini_batch):\n non_final_next_states = torch.cat([s for s in mini_batch.next_state\n if s is not None])\n return non_final_next_states","def backtrack(self):\n print('0')\n if len(self.Stack):\n step = self.Stack.pop()\n # Restore all the Knot affected by the last collapse.\n for (position, space) in step.items():\n self[position] = Knot(space)\n self.wait_to_collapse.add(position)\n return set(step.keys())\n else:\n raise CollapseError(\"No Sulotion\")","def repackage_hidden(h):\n if args.algo == \"lstm\":\n if isinstance(h, torch.Tensor):\n return h.detach()\n else:\n return tuple(repackage_hidden(v) for v in h)\n hidden = []\n for i in range(args.nlayers):\n if isinstance(h[i], torch.Tensor):\n hidden.append(h[i].detach())\n else:\n hidden.append(tuple((h[i][0].detach(), h[i][1].detach())))\n return hidden","def repackage_hidden(h):\n if args.algo == \"lstm\":\n if isinstance(h, torch.Tensor):\n return h.detach()\n else:\n return tuple(repackage_hidden(v) for v in h)\n hidden = []\n for i in range(args.nlayers):\n if isinstance(h[i], torch.Tensor):\n hidden.append(h[i].detach())\n else:\n hidden.append(tuple((h[i][0].detach(), h[i][1].detach())))\n return hidden","def forward(self, input, hidden_states):\n h, c = self.ih2h(input, hidden_states[0])\n next_hiddens = [(h, c)]\n h, c = self.h2h(h, hidden_states[1])\n next_hiddens.append((h, c))\n output = self.log_softmax(self.h2o(h))\n return output, next_hiddens","def remove_final_hidden_if_possible(net, fm):\n sink = list(fm.keys())[0]\n last_hidden = list(sink.in_arcs)[0].source\n source_places_last_hidden = [x.source for x in last_hidden.in_arcs]\n removal_possible = len(source_places_last_hidden) == 1\n for place in source_places_last_hidden:\n if len(place.out_arcs) > 1:\n removal_possible = False\n break\n else:\n source_trans = set([x.source for x in place.in_arcs])\n for trans in source_trans:\n if len(trans.out_arcs) > 1:\n removal_possible = False\n break\n if removal_possible:\n all_sources = set()\n remove_transition(net, last_hidden)\n i = 0\n while i < len(source_places_last_hidden):\n place = source_places_last_hidden[i]\n source_trans = set([x.source for x in place.in_arcs])\n for trans in source_trans:\n if trans not in all_sources:\n all_sources.add(trans)\n add_arc_from_to(trans, sink, net)\n remove_place(net, place)\n i = i + 1\n return net","def compact_neighb(self):\n order = np.argsort(self.edges[:, 0] * float(self.V) + self.edges[:, 1])\n neighb = self.edges[order, 1].astype(np.int_)\n weights = self.weights[order]\n degree, _ = self.degrees()\n idx = np.hstack((0, np.cumsum(degree))).astype(np.int_)\n return idx, neighb, weights","def get_reverse_state_arr(self):\n rpos = self.sim.getAgentPosition(self.robot_num)\n rvel = self.sim.getAgentVelocity(self.robot_num)\n rrad = self.sim.getAgentRadius(self.robot_num)\n v_pref = self.sim.getAgentMaxSpeed(self.robot_num)\n theta = math.atan2(rvel[1], rvel[0])\n # Robot's state entry.\n state = [\n rpos[0], rpos[1], rvel[0], rvel[1], rrad,\n self.headings[self.robot_num], self.overall_robot_goal[0],\n self.overall_robot_goal[1], v_pref, theta\n ]\n for obs in self.obstacles:\n if len(obs) > 1:\n # Polygonal obstacle\n o = Polygon(obs)\n p = Point(rpos)\n p1, p2 = nearest_points(o, p)\n # Velocity is always 0 for obstacles\n # Heading is same as robot's\n state.extend([p1.x, p2.y, 0, 0, self.obs_width,\n self.headings[self.robot_num]])\n else:\n # Point obstacle\n state.extend([obs[0][0], obs[0][1], 0, 0, self.obs_width,\n self.headings[self.robot_num]])\n return state","def next_states(self):\n return self.get_next_states()","def get_initial_hx(self, input_seq, hidden_state):\n num_directions = 2 if self.lstm.bidirectional else 1\n # hidden state\n hidden = hidden_state.view(self.lstm.num_layers * num_directions, len(hidden_state), -1)\n # cell state\n c_zeros = torch.zeros(self.lstm.num_layers * num_directions,\n input_seq.size(0), self.lstm.hidden_size,\n dtype=input_seq.dtype, device=input_seq.device)\n return hidden, c_zeros","def _bridge_bidirectional_hidden(self, hidden):\n num_layers = hidden.size(0) // 2\n _, batch_size, hidden_size = hidden.size()\n return hidden.view(num_layers, 2, batch_size, hidden_size)\\\n .transpose(1, 2).contiguous().view(num_layers, batch_size, hidden_size * 2)","def get_final_machine_state(self):\n\t\treturn self.machine_state","def last_state(self):\n return self._simstate","def init_hidden_state(self, batch_size):\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\n return h, c","def init_hidden_state(self, batch_size):\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\n return h, c","def init_hidden_state(self, batch_size):\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\n return h, c","def init_hidden_state(self,batch_size):\n h = torch.zeros(batch_size,self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size,self.decoder_dim).to(device)\n return h, c","def init_hidden_state(self, batch_size):\n hidden_state = tf.tile(self.initial_hidden_state[None, ...], [batch_size, 1])\n cell_state = tf.tile(self.initial_cell_state[None, ...], [batch_size, 1])\n return hidden_state, cell_state","def _init_state(self, encoder_hidden):\n if encoder_hidden is None:\n return None\n if isinstance(encoder_hidden, tuple):\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\n else:\n encoder_hidden = self._cat_directions(encoder_hidden)\n return encoder_hidden","def _init_state(self, encoder_hidden):\n if encoder_hidden is None:\n return None\n if isinstance(encoder_hidden, tuple):\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\n else:\n encoder_hidden = self._cat_directions(encoder_hidden)\n return encoder_hidden","def backward_step(nx, nh, ndlogp, w2):\n dw2 = np.einsum('nh,nk->kh', nh, ndlogp)\n dh = np.einsum('nk,kh->nh', ndlogp, w2)\n dh[nh <= 0] = 0\n dw1 = np.einsum('nh,ni->hi', dh, nx)\n return dw1, dw2","def __getstate__(self):\n return (self.layers, self.best_loss)","def detach_hidden(h):\n if isinstance(h, torch.Tensor):\n return h.detach()\n return tuple(detach_hidden(v) for v in h)","def prune_states(state: PushState) -> PushState:\n if state and not state[-1]:\n return PushGame.prune_states(state[:-1])\n else:\n return state","def get_outputs():\n all_hidden_states = get_states()\n all_attention = tf.map_fn(get_attention, all_hidden_states)\n a_values = tf.nn.softmax(all_attention, axis = 0)\n final_hidden_state = tf.einsum('ijk,ijl->jkl', a_values, \n all_hidden_states)\n output = tf.nn.sigmoid(tf.matmul(final_hidden_state[:,0,:], Wo) + bo, \n name='outputs')\n return output, a_values","def get_next_states(self):\n return self.__next_state","def _scan_multiple_steps_backwards():\n\n def backward_step(log_previous_step, log_prob_observation):\n return _log_matrix_vector(\n log_transition,\n log_prob_observation + log_previous_step)\n\n backward_log_adjoint_probs = tf.scan(\n backward_step,\n observation_log_probs[1:],\n initializer=log_adjoint_prob,\n reverse=True,\n name=\"backward_log_adjoint_probs\")\n\n return tf.concat([backward_log_adjoint_probs,\n [log_adjoint_prob]], axis=0)","def _compute_masked_hidden(self, hidden, mask):\r\n mask = mask.unsqueeze(-1).expand_as(hidden)\r\n hidden_masked = hidden[mask].contiguous().view(-1, hidden.size(-1))\r\n return hidden_masked","def get_last_run_propagated_state_history(self) -> dict:\n return self.dynamics_simulator.get_equations_of_motion_numerical_solution_raw()","def second_neighboring_sites(self, all=False):\n strides = [1, -1] if all else [1]\n funcs = [self.b1_hop, self.b2_hop, self.b3_hop]\n return self._neighboring_sites(strides, funcs)","def next_states(self, state):\n import copy\n\n ans = []\n current_array = state.board.array\n space_pos = state.board.space\n\n up_pos = [space_pos[0] - 1, space_pos[1]]\n down_pos = [space_pos[0] + 1, space_pos[1]]\n left_pos = [space_pos[0], space_pos[1] - 1]\n right_pos = [space_pos[0], space_pos[1] + 1]\n\n # down position\n if self.__is_valid(down_pos):\n down_array = [copy.copy(row) for row in current_array]\n down_board = Board(array=down_array, space=space_pos.copy())\n down_board.swap(down_pos)\n ans.append(State(board=down_board, came_from=state, move='U'))\n\n # up position\n if self.__is_valid(up_pos):\n up_array = [copy.copy(row) for row in current_array]\n up_board = Board(array=up_array, space=space_pos.copy())\n up_board.swap(up_pos)\n ans.append(State(board=up_board, came_from=state, move='D'))\n\n # right position\n if self.__is_valid(right_pos):\n right_array = [copy.copy(row) for row in current_array]\n right_board = Board(array=right_array, space=space_pos.copy())\n right_board.swap(right_pos)\n ans.append(State(board=right_board, came_from=state, move='L'))\n\n # left position\n if self.__is_valid(left_pos):\n left_array = [copy.copy(row) for row in current_array]\n left_board = Board(array=left_array, space=space_pos.copy())\n left_board.swap(left_pos)\n ans.append(State(board=left_board, came_from=state, move='R'))\n\n return ans","def reverse_state(self):\n state = np.array(self.get_reverse_state_arr())\n om = utils.build_occupancy_maps(utils.build_humans(state))\n # print(\"OM: \", om.size())\n # We only have a batch of one so just get the first element of\n # transform and rotate\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\n # print(\"State: \", state.size())\n return torch.cat((state, om), dim=1).unsqueeze(0)","def backward_step():\n #print 'a step backward'\n maze.turn_left()\n maze.turn_left()\n if maze.found():\n return maze.found()\n maze.go()\n maze.turn_left()\n maze.turn_left()","def _get_all_end_states(self, beam_tokens: Tensor, beam_scores: Tensor, beam_prev_indices: Tensor, num_steps: int) ->Tensor:\n min_score = float('inf')\n min_index = -1\n end_states = torch.jit.annotate(List[Tensor], [])\n prev_hypo_is_finished = torch.zeros(self.beam_size).byte()\n position = 1\n while bool(position <= num_steps):\n hypo_is_finished = torch.zeros(self.beam_size).byte()\n for hyp_index in range(self.beam_size):\n prev_pos = beam_prev_indices[position][hyp_index]\n hypo_is_finished[hyp_index] = prev_hypo_is_finished[prev_pos]\n if bool(hypo_is_finished[hyp_index] == 0):\n if bool(beam_tokens[position][hyp_index] == self.eos_token_id) or bool(position == num_steps):\n if bool(self.stop_at_eos):\n hypo_is_finished[hyp_index] = 1\n hypo_score = float(beam_scores[position][hyp_index])\n if bool(self.length_penalty != 0):\n hypo_score = hypo_score / float(position) ** float(self.length_penalty)\n end_states, min_score, min_index = self._add_to_end_states(end_states, min_score, torch.tensor([hypo_score, float(position), float(hyp_index)]), min_index)\n prev_hypo_is_finished = hypo_is_finished\n position = position + 1\n end_states = torch.stack(end_states)\n _, sorted_end_state_indices = end_states[:, 0].sort(dim=0, descending=True)\n end_states = end_states[sorted_end_state_indices, :]\n return end_states","def backward(self, canon):\n b = self.backwards.get(canon)\n if b is None:\n b = self.backwards.get(canon.lower())\n\n return b or []","def latest_state_data(self):\n if not self.state_list:\n return None\n if not self.state_list[-1]:\n return None\n return self.state_list[-1]","def _init_rnn_state(self, encoder_hidden):\n if encoder_hidden is None:\n return None\n if isinstance(encoder_hidden, tuple):\n encoder_hidden = tuple(\n [self._cat_directions(h) for h in encoder_hidden])\n else:\n encoder_hidden = self._cat_directions(encoder_hidden)\n return encoder_hidden","def reset_backward_rnn_state(states):\n if isinstance(states, (list, tuple)):\n for state in states:\n state[1::2] = 0.\n else:\n states[1::2] = 0.\n return states","def successors(self):\n next_states = []\n if self.stock_pile:\n tableau = self.tableau\n stock = self.stock_pile[1:]\n waste = self.stock_pile[0]\n next_states.append(State(tableau, stock, waste))\n for i, card in enumerate(self.tableau):\n if self.is_face_up(i) and self.can_be_moved(card):\n tableau = tuple(c if c != card else None for c in self.tableau)\n stock = self.stock_pile\n waste = card\n next_states.append(State(tableau, stock, waste))\n return next_states","def forward(self, h_states, seq_start_end, end_pos):\n pool_h = []\n\n for _, (start, end) in enumerate(seq_start_end):\n # Get ids of first and last pedestrian in sequence\n start = start.item()\n end = end.item()\n num_ped = end - start\n\n grid_size = self.grid_size * self.grid_size\n\n curr_hidden = h_states.view(-1, self.h_dim)[start:end]\n curr_hidden_repeat = curr_hidden.repeat(num_ped, 1)\n curr_end_pos = end_pos[start:end]\n curr_pool_h_size = (num_ped * grid_size) + 1\n curr_pool_h = curr_hidden.new_zeros((curr_pool_h_size, self.h_dim))\n\n # Get boundaries of grid\n top_left, bottom_right = self.get_bounds(curr_end_pos)\n # Repeat position -> P1, P2, P1, P2\n curr_end_pos = curr_end_pos.repeat(num_ped, 1)\n # Repeat bounds -> B1, B1, B2, B2\n top_left = self.repeat(top_left, num_ped)\n bottom_right = self.repeat(bottom_right, num_ped)\n\n # Get grid positions of neighbors for each pedestrian\n grid_pos = self.get_grid_locations(top_left, curr_end_pos).type_as(seq_start_end)\n\n # == Mark all positions to exclude as non-zero ==\n\n # Find which peds to exclude\n x_bound = ((curr_end_pos[:, 0] >= bottom_right[:, 0]) +\n (curr_end_pos[:, 0] <= top_left[:, 0]))\n y_bound = ((curr_end_pos[:, 1] >= top_left[:, 1]) +\n (curr_end_pos[:, 1] <= bottom_right[:, 1]))\n\n # Get inidicees of curr_end_pos for which it is out of neighborhood\n within_bound = x_bound + y_bound\n within_bound[0::num_ped + 1] = 1 # Don't include the ped itself\n within_bound = within_bound.view(-1)\n\n # This is a tricky way to get scatter add to work. Helps me avoid a\n # for loop. Offset everything by 1. Use the initial 0 position to\n # dump all uncessary adds.\n grid_pos += 1\n total_grid_size = self.grid_size * self.grid_size\n offset = torch.arange( 0, total_grid_size * num_ped, total_grid_size).type_as(seq_start_end)\n\n offset = self.repeat(offset.view(-1, 1), num_ped).view(-1)\n grid_pos += offset\n grid_pos[within_bound != 0] = 0\n grid_pos = grid_pos.view(-1, 1).expand_as(curr_hidden_repeat)\n\n if grid_pos.max() > curr_pool_h.shape[0]:\n print(\"ERROR EXCEED!\")\n print(grid_pos.max())\n print(curr_pool_h.shape)\n if grid_pos.min() < 0:\n print(\"ERROR UNDER!\")\n print(grid_pos.min())\n print(curr_pool_h.shape)\n\n # Perform grid-based pooling with scatter_add-function\n curr_pool_h = curr_pool_h.scatter_add(0, grid_pos,curr_hidden_repeat)\n curr_pool_h = curr_pool_h[1:]\n pool_h.append(curr_pool_h.view(num_ped, -1))\n\n pool_h = torch.cat(pool_h, dim=0)\n pool_h = self.mlp_pool(pool_h)\n\n return pool_h","def test_propagate_backward_last_hidden(self):\n nn = NeuralNet(0, 0, '', '', blank=True)\n nn.create_net(2, 1, 2, 2)\n nn.eta = 0.1\n\n # Override weights to static value for reproducibility\n for node in nn.layers[2].nodes:\n node.weights = [0.6, 0.6]\n\n for node in nn.layers[3].nodes:\n node.weights = [1.0, 1.0]\n\n # Walk forward\n nn.propagate_forward([2, 3], test=True)\n\n # Walk backward\n nn.propagate_backward([0])\n\n test_weight = nn.layers[-1].nodes[0].weights[0]\n self.assertEqual(round(test_weight, 4), 0.9901)","def init_hidden(self, batch_size: int, device: Device) -> AmbiguousHidden:\n hidden_zero = torch.zeros(batch_size, self.hidden_size).to(device)\n\n if self.rnn_type == \"LSTM\":\n return hidden_zero, hidden_zero.clone()\n else:\n return hidden_zero","def softmax_last_hidden(nr_class, *, exclusive_classes=True, **cfg):\n width = cfg[\"token_vector_width\"]\n return chain(\n get_last_hidden,\n flatten_add_lengths,\n Pooling(mean_pool),\n Softmax(nr_class, width),\n )","def stateDanglingNodes(self):\r\n state = []\r\n for i in range(len(self.metaSpikes)):\r\n if self.metaSpikes[i].typeSpike == 1:\r\n #print (\"Inside type 1 \\n\")\r\n #print (\"The number of DNs is: \" + str(len(self.metaSpikes[i].danglingNodeList)) + \"\\n\")\r\n for j in range(len(self.metaSpikes[i].danglingNodeList)):\r\n state.append(self.metaSpikes[i].danglingNodeList[j].node.state)\r\n\r\n # print (\"Node in list \\n\")\r\n else:\r\n #print (\"The number of DTs is: \" + str(len(self.metaSpikes[i].danglingTailList)) + \"\\n\")\r\n #print (\"Inside type 2 \\n\")\r\n for j in range(len(self.metaSpikes[i].danglingTailList)):\r\n for k in range(len(self.metaSpikes[i].danglingTailList[j].nodeList)):\r\n state.append(self.metaSpikes[i].danglingTailList[j].nodeList[k].state)\r\n\r\n #print (\"The state of dangling nodes is: \\n\" + str(state) + \"\\n\")\r\n #print (\"The length of dangling nodes is: \\n\" + str(len(state)) + \"\\n\") \r\n \r\n return state","def getAbsorbingStates(m):\n\t\n a=[]\n for r in range(len(m)):\n if(sum(m[r])==0): a.append(r)\n return a","def get_initial_ff_state(m):\n return [True] + [False] * (m-1)","def get_recent_state(self, current_observation):\n # This code is slightly complicated by the fact that subsequent observations might be\n # from different episodes. We ensure that an experience never spans multiple episodes.\n # This is probably not that important in practice but it seems cleaner.\n state = [current_observation]\n idx = len(self.recent_observations) - 1\n for offset in range(0, self.window_length - 1):\n current_idx = idx - offset\n current_terminal = self.recent_terminals[current_idx - 1] if current_idx - 1 >= 0 else False\n if current_idx < 0 or (not self.ignore_episode_boundaries and current_terminal):\n # The previously handled observation was terminal, don't add the current one.\n # Otherwise we would leak into a different episode.\n break\n state.insert(0, self.recent_observations[current_idx])\n while len(state) < self.window_length:\n state.insert(0, zeroed_observation(state[0]))\n return state","def _get_output_steps_to_beam_indices(self, end_state: Tensor, beam_prev_indices: Tensor) ->List[int]:\n present_position = int(end_state[1])\n beam_index = int(end_state[2])\n beam_indices = torch.jit.annotate(List[int], [])\n while present_position >= 0:\n beam_indices.insert(0, beam_index)\n beam_index = int(beam_prev_indices[present_position][beam_index])\n present_position = present_position - 1\n return beam_indices","def forward(\n self,\n batch_cur_tkids: torch.Tensor,\n batch_prev_states: Optional[Tuple[List[torch.Tensor], List[torch.Tensor]]] = None,\n ) -> Tuple[torch.Tensor, Tuple[List[torch.Tensor], List[torch.Tensor]]]:\n # Use initial hidden states and memory cell initial internal states if `batch_prev_states is None`.\n if batch_prev_states is None:\n batch_prev_states = [[None] * self.n_lyr, [None] * self.n_lyr]\n\n # Lookup token embeddings and feed to recurrent units.\n # In shape: (B, S).\n # Out shape: (B, S, d_hid).\n rnn_in = self.fc_e2h(self.emb(batch_cur_tkids))\n\n # Loop through each layer and gather last hidden states and memory cell last internal states of each layer.\n batch_cur_states: Tuple[List[torch.Tensor], List[torch.Tensor]] = ([], [])\n for lyr in range(self.n_lyr):\n # Fetch memory cell previous internal states of a layer.\n # Shape: (B, S, n_blk, d_blk).\n c_0 = batch_prev_states[0][lyr]\n\n # Fetch previous hidden states of a layer.\n # Shape: (B, S, d_hid).\n h_0 = batch_prev_states[1][lyr]\n\n # Get the `lyr`-th RNN layer and the `lyr`-th dropout layer.\n rnn_lyr = self.stack_rnn[2 * lyr]\n dropout_lyr = self.stack_rnn[2 * lyr + 1]\n\n # Use previous RNN layer's output as next RNN layer's input.\n # In shape: (B, S, d_hid).\n # rnn_c_out shape: (B, S, n_blk, d_blk).\n # rnn_h_out shape: (B, S, d_hid).\n rnn_c_out, rnn_h_out = rnn_lyr(x=rnn_in, c_0=c_0, h_0=h_0)\n\n # Record the last internal states.\n batch_cur_states[0].append(rnn_c_out[:, -1, :, :].detach())\n\n # Record the last hidden states.\n batch_cur_states[1].append(rnn_h_out[:, -1, :].detach())\n\n # Apply dropout to the output.\n # In shape: (B, S, d_hid).\n # Out shape: (B, S, d_hid).\n rnn_h_out = dropout_lyr(rnn_h_out)\n\n # Update RNN layer's input.\n rnn_in = rnn_h_out\n\n # Transform hidden states to next token embeddings.\n # Shape: (B, S, d_emb).\n z = self.fc_h2e(rnn_h_out)\n\n # Calculate similarity scores by calculating inner product over all token embeddings.\n # Shape: (B, S, V).\n sim = z @ self.emb.weight.transpose(0, 1)\n return (sim, batch_cur_states)","def process_traffic_lights(self):\n #DONE find the closest visible traffic light (if one exists within LOOKAHEAD_WPS)\n if self.init:\n state = self.get_light_state(0)\n return -1, TrafficLight.UNKNOWN\n elif self.ntlwp:\n state = self.get_light_state(self.ntlwp)\n # state = TrafficLight.RED\n return self.ntlwp, state\n return -1, TrafficLight.UNKNOWN","def deconstruct_tail(self):\n ret = []\n for ii in range(len(self.__data)):\n op = self.__data[-ii - 1].deconstruct()\n if not op:\n return (self.__data[:len(self.__data) - ii], ret)\n ret = op + ret\n return ([], ret)","def get_reward_states(self):\n state1 = State(7, 7)\n return [state1]","def backward(self, dout):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n for l in range(len(self.layers)-1,-1,-1):\n act_dout = self.activations[l].backward(dout)\n dout = self.layers[l].backward(act_dout)\n ########################\n # END OF YOUR CODE #\n #######################\n\n return","def get_state_vars(state):\n x_n = state[0, :] # x_n\n x_m = np.roll(x_n, -1) # x_{n+1}\n x_m[-1] += Length # the first one goes ahead by Length\n dx_n = state[1, :] # dx_n\n dx_m = np.roll(dx_n, -1) # dx_{n+1}\n dist = x_m - x_n\n if (dist <= 0).any():\n logging.critical(\"CRITICAL: Negative distances\")\n return x_n, x_m, dx_n, dx_m, dist","def __get_actions(self, state, next_states):\r\n val_tok_mov = np.zeros((4, 4))\r\n for token_id in range(4):\r\n val_tok_mov[token_id] = self.__valid_token_moves(state, next_states[token_id], token_id)\r\n\r\n actions = np.logical_or.reduce((val_tok_mov[0,:], val_tok_mov[1,:], val_tok_mov[2,:], val_tok_mov[3,:]))\r\n\r\n return actions, val_tok_mov","def get_on_neurons(Fish,state):\r\n state_snap= Fish[state,:]\r\n \r\n label=[]\r\n for i in range(len(state_snap)):\r\n if state_snap[i]>2:\r\n label.append(1)\r\n else: \r\n label.append(0)\r\n return label","def state_reset():\n feat_self = get_self_feat(model, data['img'][0])\n feat_diff = torch.zeros_like(feat_self)\n feat_FAR = torch.tensor([0.]).cuda()\n feat_history = torch.zeros([10]).cuda()\n\n return [feat_diff, feat_self, feat_FAR, feat_history]","def get_representation(output):\n\n # shape: (seq_len, vocab_size)\n hidden_states = output[1]\n\n token_embeddings = torch.stack(hidden_states, dim=0)\n # remove dimension 1 (batches)\n token_embeddings = torch.squeeze(token_embeddings, dim=1)\n # swap dimension 0 and 1\n token_embeddings = token_embeddings.permute(1, 0, 2)\n # the last hidden layer output (2+seq_len, 768)\n hidden_states = [token[-1] for token in token_embeddings]\n\n return hidden_states","def getRelayStates(self): \n relayStates = self.values[RELAY_STATES]\n\n relay1 = bool(relayStates & 0b0001)\n relay2 = bool(relayStates & 0b0010)\n relay3 = bool(relayStates & 0b0100)\n relay4 = bool(relayStates & 0b1000)\n\n return relay1, relay2, relay3, relay4","def get_action_outcomes(self, state, action):\r\n temp_state = tuple([max(0, min(self.pond_size[i]-1, state[i] + self.action_directions[action][i]))\r\n for i in range(2)])\r\n return self.transition_lists[temp_state]","def forward(self, z, hidden):\n\n # Decode\n l1, hidden = self.decode_RNN(z, hidden)\n decoded = self.decode_FC(l1) # fully connected layer\n\n return decoded, hidden","def forward(self, z, hidden):\n\n # Decode\n l1, hidden = self.decode_RNN(z, hidden)\n decoded = self.decode_FC(l1) # fully connected layer\n\n return decoded, hidden","def init_hidden_states(self, encoder_out):\n mean_encoder_out = encoder_out.mean(dim=1)\n h = self.init_h(mean_encoder_out) # (batch_size, decoder_dim)\n c = self.init_c(mean_encoder_out)\n\n return h, c","def _get_state(self):\n start = self.design.first_unassigned_site\n return self.target.padded_encoding[\n start : start + 2 * self._env_config.state_radius + 1\n ]","def extractstates(self, bias=1.0):\n items = []\n print(\"weights:\")\n print([round(comp.weight, 7) for comp in self.gmm])\n for comp in self.gmm:\n val = comp.weight * float(bias)\n if val > 0.5:\n for _ in range(int(round(val))):\n items.append(deepcopy(comp.loc))\n for x in items: print(x.T)\n return items","def repackage_hidden(h):\n if type(h) != tuple: # if the hidden state is a variable (see imports)\n return h.detach() # detach from history\n else:\n return tuple(repackage_hidden(v) for v in h)","def extract_goal_state(self):\n time = rospy.get_time()\n ref_time = time - self.last_time\n future_time = ref_time + self.update_rate\n\n # get state of future time in global trajectory\n return df.compute_output3D(self.global_solution, self.order, self.time[self.future_index], future_time)"],"string":"[\n \"def extract_hidden_states(self, output):\\n # Intermediate hidden states\\n output_fw_intermediate = output[:,:-1,0:self._hidden_size]\\n output_bw_intermediate = output[:,1:,self._hidden_size:] \\n \\n # Last hidden states\\n output_fw = output[:,-1,0:self._hidden_size]\\n output_bw = output[:,0,self._hidden_size:]\\n last_ht = torch.cat((output_fw, output_bw), -1)\\n \\n return last_ht, output_fw_intermediate, output_bw_intermediate\",\n \"def extract_last_hidden_state(hidden_state):\\n seq_len, hidden_size = hidden_state.size()\\n assert hidden_size % 2 == 0\\n split_point = hidden_size // 2\\n last_hidden_state = torch.cat(\\n [hidden_state[-1, :split_point], hidden_state[0, split_point:]], dim=0\\n )\\n return last_hidden_state\",\n \"def extract_last_hidden_state_batched(hidden_state, lengths, bidirectional):\\n bs, seq_len, hidden_size = hidden_state.size()\\n assert bs == len(lengths)\\n assert hidden_size % 2 == 0\\n split_point = hidden_size // 2\\n\\n length_v = torch.stack(lengths, dim=0)\\n if bidirectional:\\n last_idx = (length_v - 1).unsqueeze(-1).unsqueeze(-1).expand(bs, 1, split_point)\\n first_idx = torch.zeros([bs, 1, split_point], dtype=torch.long)\\n batched_idx = torch.cat([last_idx, first_idx], dim=-1).to(hidden_state.device)\\n last_hidden_state = torch.gather(\\n hidden_state, dim=1, index=batched_idx\\n ).squeeze(1)\\n else:\\n last_idx = (\\n (length_v - 1)\\n .unsqueeze(-1)\\n .unsqueeze(-1)\\n .expand(bs, 1, hidden_size)\\n .to(hidden_state.device)\\n )\\n last_hidden_state = torch.gather(hidden_state, dim=1, index=last_idx).squeeze(1)\\n\\n return last_hidden_state\",\n \"def get_last_hidden(docs, drop=0.0):\\n outputs = [doc._.get(ATTRS.last_hidden_state) for doc in docs]\\n for out in outputs:\\n assert out is not None\\n assert out.size != 0\\n\\n def backprop_last_hidden(d_outputs, sgd=None):\\n for doc, d_lh in zip(docs, d_outputs):\\n xp = get_array_module(d_lh)\\n shape = d_lh.shape\\n dtype = d_lh.dtype\\n if doc._.get(ATTRS.d_last_hidden_state).size == 0:\\n doc._.set(ATTRS.d_last_hidden_state, xp.zeros(shape, dtype=dtype))\\n doc._.set(\\n ATTRS.d_last_hidden_state, doc._.get(ATTRS.d_last_hidden_state) + d_lh\\n )\\n return None\\n\\n return outputs, backprop_last_hidden\",\n \"def neighboring_states(self):\\n index = self.state.index(0)\\n\\n if index == 0:\\n return [self.move(movement) for movement in ['down', 'right']]\\n elif index == 1:\\n return [self.move(movement) for movement in ['down', 'left', 'right']]\\n elif index == 2:\\n return [self.move(movement) for movement in ['down', 'left']]\\n elif index == 3:\\n return [self.move(movement) for movement in ['up', 'down', 'right']]\\n elif index == 4:\\n return [self.move(movement) for movement in ['up', 'down', 'left', 'right']]\\n elif index == 5:\\n return [self.move(movement) for movement in ['up', 'down', 'left']]\\n elif index == 6:\\n return [self.move(movement) for movement in ['up', 'right']]\\n elif index == 7:\\n return [self.move(movement) for movement in ['up', 'left', 'right']]\\n else:\\n # index == 8\\n return [self.move(movement) for movement in ['up', 'left']]\",\n \"def get_latest_states(self) -> Tuple:\\n # Ensure index is in an allowable range\\n assert self.step <= self.num_steps\\n\\n o_t = self.obs_buffer[self.step].unsqueeze(0)\\n h_tminus1 = self.hid_buffer[self.step].unsqueeze(0)\\n m_t = self.don_buffer[self.step].unsqueeze(0)\\n\\n return o_t, h_tminus1, m_t\",\n \"def next_states(self):\\n return self._states[1:]\",\n \"def final_states(self) -> Tuple[tuple, ...]:\\n return self._final_states\",\n \"def get_output_states(self):\\n return self.states[-self.num_output_states:]\",\n \"def find_dark_states(excited_state, ground_states):\",\n \"def get_rnn_hidden_state(h):\\n return h if not isinstance(h, tuple) else h[0]\",\n \"def iter_final_states(self):\\n from six.moves import filter\\n return filter(lambda s:s.is_final, self.iter_states())\",\n \"def get_previous_nodes_states(self, n):\\n return self.simulation_output[-n - 1]\",\n \"def extract_lstm_minus_feature(hidden_state, i, j):\\n seq_len, bs, hidden_size = hidden_state.size()\\n assert hidden_size % 2 == 0\\n split_point = hidden_size // 2\\n hidden_f = hidden_state[j + 1, :, :split_point] - hidden_state[i, :, :split_point]\\n hidden_b = (\\n hidden_state[i + 1, :, split_point:] - hidden_state[j + 2, :, split_point:]\\n )\\n span_v = torch.cat([hidden_f, hidden_b], dim=-1)\\n return span_v\",\n \"def final_states(self):\\n return list(self.iter_final_states())\",\n \"def get_states():\\n # Getting all hidden state through time\\n all_hidden_states = tf.scan(GRU, processed_input, \\n initializer=initial_hidden, name='states')\\n return all_hidden_states\",\n \"def _backtrack(self, nw_output, nw_hidden, predecessors, symbols, scores, b, hidden_size):\\n\\n lstm = isinstance(nw_hidden[0], tuple)\\n\\n # initialize return variables given different types\\n output = list()\\n h_t = list()\\n p = list()\\n # Placeholder for last hidden state of top-k sequences.\\n # If a (top-k) sequence ends early in decoding, `h_n` contains\\n # its hidden state when it sees EOS. Otherwise, `h_n` contains\\n # the last hidden state of decoding.\\n if lstm:\\n state_size = nw_hidden[0][0].size()\\n h_n = tuple([torch.zeros(state_size).to(device), torch.zeros(state_size).to(device)])\\n else:\\n h_n = torch.zeros(nw_hidden[0].size()).to(device)\\n l = [[self.max_length] * self.k for _ in range(b)] # Placeholder for lengths of top-k sequences\\n # Similar to `h_n`\\n\\n # the last step output of the beams are not sorted\\n # thus they are sorted here\\n sorted_score, sorted_idx = scores[-1].view(b, self.k).topk(self.k)\\n # initialize the sequence scores with the sorted last step beam scores\\n s = sorted_score.clone()\\n\\n batch_eos_found = [0] * b # the number of EOS found\\n # in the backward loop below for each batch\\n\\n t = self.max_length - 1\\n # initialize the back pointer with the sorted order of the last step beams.\\n # add self.pos_index for indexing variable with b*k as the first dimension.\\n t_predecessors = (sorted_idx + self.pos_index.expand_as(sorted_idx)).view(b * self.k)\\n while t >= 0:\\n # Re-order the variables with the back pointer\\n current_output = nw_output[t].index_select(0, t_predecessors)\\n if lstm:\\n current_hidden = tuple([h.index_select(1, t_predecessors) for h in nw_hidden[t]])\\n else:\\n current_hidden = nw_hidden[t].index_select(1, t_predecessors)\\n current_symbol = symbols[t].index_select(0, t_predecessors)\\n # Re-order the back pointer of the previous step with the back pointer of\\n # the current step\\n t_predecessors = predecessors[t].index_select(0, t_predecessors).squeeze()\\n\\n # This tricky block handles dropped sequences that see EOS earlier.\\n # The basic idea is summarized below:\\n #\\n # Terms:\\n # Ended sequences = sequences that see EOS early and dropped\\n # Survived sequences = sequences in the last step of the beams\\n #\\n # Although the ended sequences are dropped during decoding,\\n # their generated symbols and complete backtracking information are still\\n # in the backtracking variables.\\n # For each batch, everytime we see an EOS in the backtracking process,\\n # 1. If there is survived sequences in the return variables, replace\\n # the one with the lowest survived sequence score with the new ended\\n # sequences\\n # 2. Otherwise, replace the ended sequence with the lowest sequence\\n # score with the new ended sequence\\n #\\n eos_indices = symbols[t].data.squeeze(1).eq(self.EOS).nonzero()\\n if eos_indices.dim() > 0:\\n for i in range(eos_indices.size(0) - 1, -1, -1):\\n # Indices of the EOS symbol for both variables\\n # with b*k as the first dimension, and b, k for\\n # the first two dimensions\\n idx = eos_indices[i]\\n b_idx = int(idx[0] // self.k)\\n # The indices of the replacing position\\n # according to the replacement strategy noted above\\n res_k_idx = self.k - (batch_eos_found[b_idx] % self.k) - 1\\n batch_eos_found[b_idx] += 1\\n res_idx = b_idx * self.k + res_k_idx\\n\\n # Replace the old information in return variables\\n # with the new ended sequence information\\n t_predecessors[res_idx] = predecessors[t][idx[0]]\\n current_output[res_idx, :] = nw_output[t][idx[0], :]\\n if lstm:\\n current_hidden[0][:, res_idx, :] = nw_hidden[t][0][:, idx[0], :]\\n current_hidden[1][:, res_idx, :] = nw_hidden[t][1][:, idx[0], :]\\n h_n[0][:, res_idx, :] = nw_hidden[t][0][:, idx[0], :].data\\n h_n[1][:, res_idx, :] = nw_hidden[t][1][:, idx[0], :].data\\n else:\\n current_hidden[:, res_idx, :] = nw_hidden[t][:, idx[0], :]\\n h_n[:, res_idx, :] = nw_hidden[t][:, idx[0], :].data\\n current_symbol[res_idx, :] = symbols[t][idx[0]]\\n s[b_idx, res_k_idx] = scores[t][idx[0]].data[0]\\n l[b_idx][res_k_idx] = t + 1\\n\\n # record the back tracked results\\n output.append(current_output)\\n h_t.append(current_hidden)\\n p.append(current_symbol)\\n\\n t -= 1\\n\\n # Sort and re-order again as the added ended sequences may change\\n # the order (very unlikely)\\n s, re_sorted_idx = s.topk(self.k)\\n for b_idx in range(b):\\n l[b_idx] = [l[b_idx][k_idx.item()] for k_idx in re_sorted_idx[b_idx, :]]\\n\\n re_sorted_idx = (re_sorted_idx + self.pos_index.expand_as(re_sorted_idx)).view(b * self.k)\\n\\n # Reverse the sequences and re-order at the same time\\n # It is reversed because the backtracking happens in reverse time order\\n output = [step.index_select(0, re_sorted_idx).view(b, self.k, -1) for step in reversed(output)]\\n p = [step.index_select(0, re_sorted_idx).view(b, self.k, -1) for step in reversed(p)]\\n if lstm:\\n h_t = [tuple([h.index_select(1, re_sorted_idx).view(-1, b, self.k, hidden_size) for h in step]) for step in reversed(h_t)]\\n h_n = tuple([h.index_select(1, re_sorted_idx.data).view(-1, b, self.k, hidden_size) for h in h_n])\\n else:\\n h_t = [step.index_select(1, re_sorted_idx).view(-1, b, self.k, hidden_size) for step in reversed(h_t)]\\n h_n = h_n.index_select(1, re_sorted_idx.data).view(-1, b, self.k, hidden_size)\\n s = s.data\\n\\n return output, h_t, h_n, s, l, p\",\n \"def _extract_states(self, state):\\n conf = self._config\\n\\n # c_prev is `m` (cell value), and\\n # m_prev is `h` (previous output) in the paper.\\n # Keeping c and m here for consistency with the codebase\\n c_prev = [None] * conf.num_dims\\n m_prev = [None] * conf.num_dims\\n\\n # for LSTM : state = memory cell + output, hence cell_output_size > 0\\n # for GRU/RNN: state = output (whose size is equal to _num_units),\\n # hence cell_output_size = 0\\n total_cell_state_size = self._cell_state_size()\\n cell_output_size = total_cell_state_size - conf.num_units\\n\\n if self._state_is_tuple:\\n if len(conf.recurrents) != len(state):\\n raise ValueError('Expected state as a tuple of {} '\\n 'element'.format(len(conf.recurrents)))\\n\\n for recurrent_dim, recurrent_state in zip(conf.recurrents, state):\\n if cell_output_size > 0:\\n c_prev[recurrent_dim], m_prev[recurrent_dim] = recurrent_state\\n else:\\n m_prev[recurrent_dim] = recurrent_state\\n else:\\n for recurrent_dim, start_idx in zip(conf.recurrents,\\n range(0, self.state_size,\\n total_cell_state_size)):\\n if cell_output_size > 0:\\n c_prev[recurrent_dim] = array_ops.slice(state, [0, start_idx],\\n [-1, conf.num_units])\\n m_prev[recurrent_dim] = array_ops.slice(\\n state, [0, start_idx + conf.num_units], [-1, cell_output_size])\\n else:\\n m_prev[recurrent_dim] = array_ops.slice(state, [0, start_idx],\\n [-1, conf.num_units])\\n return c_prev, m_prev, cell_output_size\",\n \"def get_final_state(self):\\n state = {}\\n s = self.copy()\\n clip = not np.isscalar(self['t'])\\n if clip:\\n # only get results for the last timepoint\\n s.set_state(self.state[:, -1])\\n \\n for k in self.difeq_vars:\\n state[k] = s[k]\\n for k in self.dep_vars:\\n state[k] = s[k]\\n for k,v in self.extra.items():\\n if clip:\\n state[k] = v[-1]\\n else:\\n state[k] = v\\n \\n return state\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def remove_initial_hidden_if_possible(net, im):\\n source = list(im.keys())[0]\\n first_hidden = list(source.out_arcs)[0].target\\n target_places_first_hidden = [x.target for x in first_hidden.out_arcs]\\n if len(target_places_first_hidden) == 1:\\n target_place_first_hidden = target_places_first_hidden[0]\\n if len(target_place_first_hidden.in_arcs) == 1:\\n new_im = Marking()\\n new_im[target_place_first_hidden] = 1\\n remove_place(net, source)\\n remove_transition(net, first_hidden)\\n return net, new_im\\n return net, im\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def Get_States(self):\\n\\n # Getting all hidden state throuh time\\n all_hidden_states = tf.scan(self.LSTM,\\n self.processed_input,\\n initializer=self.initial_hidden,\\n name='states')\\n all_hidden_states=all_hidden_states[:,0,:,:]\\n \\n return all_hidden_states\",\n \"def get_final_states(self):\\r\\n return set(self.final_states)\",\n \"def stabilize(self, hidden, num_iters=1):\\n for i in range(num_iters):\\n g_off, hidden = self.add_transit(old_hidden=hidden)\\n return g_off, hidden\",\n \"def hidden_layers(self):\\n\\t\\tif self.hidden is None:\\n\\t\\t\\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\\n\\t\\t\\tlast_hidden = self.x\\n\\t\\t\\tif self.covnet == 1:\\n\\t\\t\\t\\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\\n\\t\\t\\telif self.covnet == 2:\\n\\t\\t\\t\\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\\n\\t\\t\\t\\t self.layerSize[0], self.layerSize[1])\\n\\t\\t\\telse:\\n\\n\\t\\t\\t\\tself._drouput = 'dr'\\n\\t\\t\\t\\t# self.hidden.append(self.x)\\n\\t\\t\\t\\tfor i in range(1, len(self.all_layer_sizes)):\\n\\t\\t\\t\\t\\tname_scope = 'hidden' + str(i - 1)\\n\\t\\t\\t\\t\\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\\n\\t\\t\\t\\t\\tactivation_function = self.activation_function\\n\\t\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\\n\\t\\t\\t\\t\\t last_hidden)\\n\\t\\t\\t\\tname_scope = 'final_layer'\\n\\t\\t\\t\\trow_size, col_size = self.layerSize[-1], self.num_of_classes\\n\\t\\t\\t\\tactivation_function = None\\n\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\\n\\t\\treturn self.hidden\",\n \"def get_final_encoder_states(encoder_outputs: torch.Tensor,\\n mask: torch.Tensor,\\n bidirectional: bool = False) -> torch.Tensor:\\n # These are the indices of the last words in the sequences (i.e. length sans padding - 1). We\\n # are assuming sequences are right padded.\\n # Shape: (batch_size,)\\n last_word_indices = mask.sum(1).long() - 1\\n\\n # handle -1 cases\\n ll_ = (last_word_indices != -1).long()\\n last_word_indices = last_word_indices * ll_\\n\\n batch_size, _, encoder_output_dim = encoder_outputs.size()\\n expanded_indices = last_word_indices.view(-1, 1, 1).expand(batch_size, 1, encoder_output_dim)\\n # Shape: (batch_size, 1, encoder_output_dim)\\n final_encoder_output = encoder_outputs.gather(1, expanded_indices)\\n final_encoder_output = final_encoder_output.squeeze(1) # (batch_size, encoder_output_dim)\\n if bidirectional:\\n final_forward_output = final_encoder_output[:, :(encoder_output_dim // 2)]\\n final_backward_output = encoder_outputs[:, 0, (encoder_output_dim // 2):]\\n final_encoder_output = torch.cat([final_forward_output, final_backward_output], dim=-1)\\n return final_encoder_output\",\n \"def mdp_state_neighbors(mdp, s):\\n neigh = set()\\n for a in mdp.actions(s):\\n for s2 in mdp.transition(s, a):\\n if not s == s2:\\n neigh.add(s2)\\n return neigh\",\n \"def dec_step(prev_chars, dec_hidden):\\n\\n scores, dec_hidden = self.forward(prev_chars, dec_hidden)\\n next_chars = scores.argmax(dim=-1)\\n return next_chars, dec_hidden\",\n \"def reset_hidden(self, hidden, reset_flags):\\n # detach it from history (pytorch mechanics)\\n if self.rnn_type in ['lstm', 'mylstm']:\\n h = Variable(hidden[0].data)\\n c = Variable(hidden[1].data)\\n hidden = (h, c)\\n for b, flag in enumerate(reset_flags):\\n if flag.data[0] == 1: # data[0] access the data in Variable\\n hidden[0][:, b, :].data.fill_(0)\\n hidden[1][:, b, :].data.fill_(0)\\n elif self.rnn_type == 'gru':\\n hidden = Variable(hidden.data)\\n for b, flag in enumerate(reset_flags):\\n if flag.data[0] == 1: # data[0] access the data in Variable\\n hidden[:, b, :].data.fill_(0)\\n else:\\n print(\\\"Not support this type yet.\\\")\\n exit(0)\\n return hidden\",\n \"def init_hidden(self):\\n # TODO ========================\\n # initialize the hidden states to zero\\n\\n initial_hidden = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)\\n return initial_hidden # a parameter tensor of shape (self.num_layers, self.batch_size, self.hidden_size)\",\n \"def getNonFinalNextStateBatch(mini_batch):\\n non_final_next_states = torch.cat([s for s in mini_batch.next_state\\n if s is not None])\\n return non_final_next_states\",\n \"def backtrack(self):\\n print('0')\\n if len(self.Stack):\\n step = self.Stack.pop()\\n # Restore all the Knot affected by the last collapse.\\n for (position, space) in step.items():\\n self[position] = Knot(space)\\n self.wait_to_collapse.add(position)\\n return set(step.keys())\\n else:\\n raise CollapseError(\\\"No Sulotion\\\")\",\n \"def repackage_hidden(h):\\n if args.algo == \\\"lstm\\\":\\n if isinstance(h, torch.Tensor):\\n return h.detach()\\n else:\\n return tuple(repackage_hidden(v) for v in h)\\n hidden = []\\n for i in range(args.nlayers):\\n if isinstance(h[i], torch.Tensor):\\n hidden.append(h[i].detach())\\n else:\\n hidden.append(tuple((h[i][0].detach(), h[i][1].detach())))\\n return hidden\",\n \"def repackage_hidden(h):\\n if args.algo == \\\"lstm\\\":\\n if isinstance(h, torch.Tensor):\\n return h.detach()\\n else:\\n return tuple(repackage_hidden(v) for v in h)\\n hidden = []\\n for i in range(args.nlayers):\\n if isinstance(h[i], torch.Tensor):\\n hidden.append(h[i].detach())\\n else:\\n hidden.append(tuple((h[i][0].detach(), h[i][1].detach())))\\n return hidden\",\n \"def forward(self, input, hidden_states):\\n h, c = self.ih2h(input, hidden_states[0])\\n next_hiddens = [(h, c)]\\n h, c = self.h2h(h, hidden_states[1])\\n next_hiddens.append((h, c))\\n output = self.log_softmax(self.h2o(h))\\n return output, next_hiddens\",\n \"def remove_final_hidden_if_possible(net, fm):\\n sink = list(fm.keys())[0]\\n last_hidden = list(sink.in_arcs)[0].source\\n source_places_last_hidden = [x.source for x in last_hidden.in_arcs]\\n removal_possible = len(source_places_last_hidden) == 1\\n for place in source_places_last_hidden:\\n if len(place.out_arcs) > 1:\\n removal_possible = False\\n break\\n else:\\n source_trans = set([x.source for x in place.in_arcs])\\n for trans in source_trans:\\n if len(trans.out_arcs) > 1:\\n removal_possible = False\\n break\\n if removal_possible:\\n all_sources = set()\\n remove_transition(net, last_hidden)\\n i = 0\\n while i < len(source_places_last_hidden):\\n place = source_places_last_hidden[i]\\n source_trans = set([x.source for x in place.in_arcs])\\n for trans in source_trans:\\n if trans not in all_sources:\\n all_sources.add(trans)\\n add_arc_from_to(trans, sink, net)\\n remove_place(net, place)\\n i = i + 1\\n return net\",\n \"def compact_neighb(self):\\n order = np.argsort(self.edges[:, 0] * float(self.V) + self.edges[:, 1])\\n neighb = self.edges[order, 1].astype(np.int_)\\n weights = self.weights[order]\\n degree, _ = self.degrees()\\n idx = np.hstack((0, np.cumsum(degree))).astype(np.int_)\\n return idx, neighb, weights\",\n \"def get_reverse_state_arr(self):\\n rpos = self.sim.getAgentPosition(self.robot_num)\\n rvel = self.sim.getAgentVelocity(self.robot_num)\\n rrad = self.sim.getAgentRadius(self.robot_num)\\n v_pref = self.sim.getAgentMaxSpeed(self.robot_num)\\n theta = math.atan2(rvel[1], rvel[0])\\n # Robot's state entry.\\n state = [\\n rpos[0], rpos[1], rvel[0], rvel[1], rrad,\\n self.headings[self.robot_num], self.overall_robot_goal[0],\\n self.overall_robot_goal[1], v_pref, theta\\n ]\\n for obs in self.obstacles:\\n if len(obs) > 1:\\n # Polygonal obstacle\\n o = Polygon(obs)\\n p = Point(rpos)\\n p1, p2 = nearest_points(o, p)\\n # Velocity is always 0 for obstacles\\n # Heading is same as robot's\\n state.extend([p1.x, p2.y, 0, 0, self.obs_width,\\n self.headings[self.robot_num]])\\n else:\\n # Point obstacle\\n state.extend([obs[0][0], obs[0][1], 0, 0, self.obs_width,\\n self.headings[self.robot_num]])\\n return state\",\n \"def next_states(self):\\n return self.get_next_states()\",\n \"def get_initial_hx(self, input_seq, hidden_state):\\n num_directions = 2 if self.lstm.bidirectional else 1\\n # hidden state\\n hidden = hidden_state.view(self.lstm.num_layers * num_directions, len(hidden_state), -1)\\n # cell state\\n c_zeros = torch.zeros(self.lstm.num_layers * num_directions,\\n input_seq.size(0), self.lstm.hidden_size,\\n dtype=input_seq.dtype, device=input_seq.device)\\n return hidden, c_zeros\",\n \"def _bridge_bidirectional_hidden(self, hidden):\\n num_layers = hidden.size(0) // 2\\n _, batch_size, hidden_size = hidden.size()\\n return hidden.view(num_layers, 2, batch_size, hidden_size)\\\\\\n .transpose(1, 2).contiguous().view(num_layers, batch_size, hidden_size * 2)\",\n \"def get_final_machine_state(self):\\n\\t\\treturn self.machine_state\",\n \"def last_state(self):\\n return self._simstate\",\n \"def init_hidden_state(self, batch_size):\\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\\n return h, c\",\n \"def init_hidden_state(self, batch_size):\\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\\n return h, c\",\n \"def init_hidden_state(self, batch_size):\\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\\n return h, c\",\n \"def init_hidden_state(self,batch_size):\\n h = torch.zeros(batch_size,self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size,self.decoder_dim).to(device)\\n return h, c\",\n \"def init_hidden_state(self, batch_size):\\n hidden_state = tf.tile(self.initial_hidden_state[None, ...], [batch_size, 1])\\n cell_state = tf.tile(self.initial_cell_state[None, ...], [batch_size, 1])\\n return hidden_state, cell_state\",\n \"def _init_state(self, encoder_hidden):\\n if encoder_hidden is None:\\n return None\\n if isinstance(encoder_hidden, tuple):\\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\\n else:\\n encoder_hidden = self._cat_directions(encoder_hidden)\\n return encoder_hidden\",\n \"def _init_state(self, encoder_hidden):\\n if encoder_hidden is None:\\n return None\\n if isinstance(encoder_hidden, tuple):\\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\\n else:\\n encoder_hidden = self._cat_directions(encoder_hidden)\\n return encoder_hidden\",\n \"def backward_step(nx, nh, ndlogp, w2):\\n dw2 = np.einsum('nh,nk->kh', nh, ndlogp)\\n dh = np.einsum('nk,kh->nh', ndlogp, w2)\\n dh[nh <= 0] = 0\\n dw1 = np.einsum('nh,ni->hi', dh, nx)\\n return dw1, dw2\",\n \"def __getstate__(self):\\n return (self.layers, self.best_loss)\",\n \"def detach_hidden(h):\\n if isinstance(h, torch.Tensor):\\n return h.detach()\\n return tuple(detach_hidden(v) for v in h)\",\n \"def prune_states(state: PushState) -> PushState:\\n if state and not state[-1]:\\n return PushGame.prune_states(state[:-1])\\n else:\\n return state\",\n \"def get_outputs():\\n all_hidden_states = get_states()\\n all_attention = tf.map_fn(get_attention, all_hidden_states)\\n a_values = tf.nn.softmax(all_attention, axis = 0)\\n final_hidden_state = tf.einsum('ijk,ijl->jkl', a_values, \\n all_hidden_states)\\n output = tf.nn.sigmoid(tf.matmul(final_hidden_state[:,0,:], Wo) + bo, \\n name='outputs')\\n return output, a_values\",\n \"def get_next_states(self):\\n return self.__next_state\",\n \"def _scan_multiple_steps_backwards():\\n\\n def backward_step(log_previous_step, log_prob_observation):\\n return _log_matrix_vector(\\n log_transition,\\n log_prob_observation + log_previous_step)\\n\\n backward_log_adjoint_probs = tf.scan(\\n backward_step,\\n observation_log_probs[1:],\\n initializer=log_adjoint_prob,\\n reverse=True,\\n name=\\\"backward_log_adjoint_probs\\\")\\n\\n return tf.concat([backward_log_adjoint_probs,\\n [log_adjoint_prob]], axis=0)\",\n \"def _compute_masked_hidden(self, hidden, mask):\\r\\n mask = mask.unsqueeze(-1).expand_as(hidden)\\r\\n hidden_masked = hidden[mask].contiguous().view(-1, hidden.size(-1))\\r\\n return hidden_masked\",\n \"def get_last_run_propagated_state_history(self) -> dict:\\n return self.dynamics_simulator.get_equations_of_motion_numerical_solution_raw()\",\n \"def second_neighboring_sites(self, all=False):\\n strides = [1, -1] if all else [1]\\n funcs = [self.b1_hop, self.b2_hop, self.b3_hop]\\n return self._neighboring_sites(strides, funcs)\",\n \"def next_states(self, state):\\n import copy\\n\\n ans = []\\n current_array = state.board.array\\n space_pos = state.board.space\\n\\n up_pos = [space_pos[0] - 1, space_pos[1]]\\n down_pos = [space_pos[0] + 1, space_pos[1]]\\n left_pos = [space_pos[0], space_pos[1] - 1]\\n right_pos = [space_pos[0], space_pos[1] + 1]\\n\\n # down position\\n if self.__is_valid(down_pos):\\n down_array = [copy.copy(row) for row in current_array]\\n down_board = Board(array=down_array, space=space_pos.copy())\\n down_board.swap(down_pos)\\n ans.append(State(board=down_board, came_from=state, move='U'))\\n\\n # up position\\n if self.__is_valid(up_pos):\\n up_array = [copy.copy(row) for row in current_array]\\n up_board = Board(array=up_array, space=space_pos.copy())\\n up_board.swap(up_pos)\\n ans.append(State(board=up_board, came_from=state, move='D'))\\n\\n # right position\\n if self.__is_valid(right_pos):\\n right_array = [copy.copy(row) for row in current_array]\\n right_board = Board(array=right_array, space=space_pos.copy())\\n right_board.swap(right_pos)\\n ans.append(State(board=right_board, came_from=state, move='L'))\\n\\n # left position\\n if self.__is_valid(left_pos):\\n left_array = [copy.copy(row) for row in current_array]\\n left_board = Board(array=left_array, space=space_pos.copy())\\n left_board.swap(left_pos)\\n ans.append(State(board=left_board, came_from=state, move='R'))\\n\\n return ans\",\n \"def reverse_state(self):\\n state = np.array(self.get_reverse_state_arr())\\n om = utils.build_occupancy_maps(utils.build_humans(state))\\n # print(\\\"OM: \\\", om.size())\\n # We only have a batch of one so just get the first element of\\n # transform and rotate\\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\\n # print(\\\"State: \\\", state.size())\\n return torch.cat((state, om), dim=1).unsqueeze(0)\",\n \"def backward_step():\\n #print 'a step backward'\\n maze.turn_left()\\n maze.turn_left()\\n if maze.found():\\n return maze.found()\\n maze.go()\\n maze.turn_left()\\n maze.turn_left()\",\n \"def _get_all_end_states(self, beam_tokens: Tensor, beam_scores: Tensor, beam_prev_indices: Tensor, num_steps: int) ->Tensor:\\n min_score = float('inf')\\n min_index = -1\\n end_states = torch.jit.annotate(List[Tensor], [])\\n prev_hypo_is_finished = torch.zeros(self.beam_size).byte()\\n position = 1\\n while bool(position <= num_steps):\\n hypo_is_finished = torch.zeros(self.beam_size).byte()\\n for hyp_index in range(self.beam_size):\\n prev_pos = beam_prev_indices[position][hyp_index]\\n hypo_is_finished[hyp_index] = prev_hypo_is_finished[prev_pos]\\n if bool(hypo_is_finished[hyp_index] == 0):\\n if bool(beam_tokens[position][hyp_index] == self.eos_token_id) or bool(position == num_steps):\\n if bool(self.stop_at_eos):\\n hypo_is_finished[hyp_index] = 1\\n hypo_score = float(beam_scores[position][hyp_index])\\n if bool(self.length_penalty != 0):\\n hypo_score = hypo_score / float(position) ** float(self.length_penalty)\\n end_states, min_score, min_index = self._add_to_end_states(end_states, min_score, torch.tensor([hypo_score, float(position), float(hyp_index)]), min_index)\\n prev_hypo_is_finished = hypo_is_finished\\n position = position + 1\\n end_states = torch.stack(end_states)\\n _, sorted_end_state_indices = end_states[:, 0].sort(dim=0, descending=True)\\n end_states = end_states[sorted_end_state_indices, :]\\n return end_states\",\n \"def backward(self, canon):\\n b = self.backwards.get(canon)\\n if b is None:\\n b = self.backwards.get(canon.lower())\\n\\n return b or []\",\n \"def latest_state_data(self):\\n if not self.state_list:\\n return None\\n if not self.state_list[-1]:\\n return None\\n return self.state_list[-1]\",\n \"def _init_rnn_state(self, encoder_hidden):\\n if encoder_hidden is None:\\n return None\\n if isinstance(encoder_hidden, tuple):\\n encoder_hidden = tuple(\\n [self._cat_directions(h) for h in encoder_hidden])\\n else:\\n encoder_hidden = self._cat_directions(encoder_hidden)\\n return encoder_hidden\",\n \"def reset_backward_rnn_state(states):\\n if isinstance(states, (list, tuple)):\\n for state in states:\\n state[1::2] = 0.\\n else:\\n states[1::2] = 0.\\n return states\",\n \"def successors(self):\\n next_states = []\\n if self.stock_pile:\\n tableau = self.tableau\\n stock = self.stock_pile[1:]\\n waste = self.stock_pile[0]\\n next_states.append(State(tableau, stock, waste))\\n for i, card in enumerate(self.tableau):\\n if self.is_face_up(i) and self.can_be_moved(card):\\n tableau = tuple(c if c != card else None for c in self.tableau)\\n stock = self.stock_pile\\n waste = card\\n next_states.append(State(tableau, stock, waste))\\n return next_states\",\n \"def forward(self, h_states, seq_start_end, end_pos):\\n pool_h = []\\n\\n for _, (start, end) in enumerate(seq_start_end):\\n # Get ids of first and last pedestrian in sequence\\n start = start.item()\\n end = end.item()\\n num_ped = end - start\\n\\n grid_size = self.grid_size * self.grid_size\\n\\n curr_hidden = h_states.view(-1, self.h_dim)[start:end]\\n curr_hidden_repeat = curr_hidden.repeat(num_ped, 1)\\n curr_end_pos = end_pos[start:end]\\n curr_pool_h_size = (num_ped * grid_size) + 1\\n curr_pool_h = curr_hidden.new_zeros((curr_pool_h_size, self.h_dim))\\n\\n # Get boundaries of grid\\n top_left, bottom_right = self.get_bounds(curr_end_pos)\\n # Repeat position -> P1, P2, P1, P2\\n curr_end_pos = curr_end_pos.repeat(num_ped, 1)\\n # Repeat bounds -> B1, B1, B2, B2\\n top_left = self.repeat(top_left, num_ped)\\n bottom_right = self.repeat(bottom_right, num_ped)\\n\\n # Get grid positions of neighbors for each pedestrian\\n grid_pos = self.get_grid_locations(top_left, curr_end_pos).type_as(seq_start_end)\\n\\n # == Mark all positions to exclude as non-zero ==\\n\\n # Find which peds to exclude\\n x_bound = ((curr_end_pos[:, 0] >= bottom_right[:, 0]) +\\n (curr_end_pos[:, 0] <= top_left[:, 0]))\\n y_bound = ((curr_end_pos[:, 1] >= top_left[:, 1]) +\\n (curr_end_pos[:, 1] <= bottom_right[:, 1]))\\n\\n # Get inidicees of curr_end_pos for which it is out of neighborhood\\n within_bound = x_bound + y_bound\\n within_bound[0::num_ped + 1] = 1 # Don't include the ped itself\\n within_bound = within_bound.view(-1)\\n\\n # This is a tricky way to get scatter add to work. Helps me avoid a\\n # for loop. Offset everything by 1. Use the initial 0 position to\\n # dump all uncessary adds.\\n grid_pos += 1\\n total_grid_size = self.grid_size * self.grid_size\\n offset = torch.arange( 0, total_grid_size * num_ped, total_grid_size).type_as(seq_start_end)\\n\\n offset = self.repeat(offset.view(-1, 1), num_ped).view(-1)\\n grid_pos += offset\\n grid_pos[within_bound != 0] = 0\\n grid_pos = grid_pos.view(-1, 1).expand_as(curr_hidden_repeat)\\n\\n if grid_pos.max() > curr_pool_h.shape[0]:\\n print(\\\"ERROR EXCEED!\\\")\\n print(grid_pos.max())\\n print(curr_pool_h.shape)\\n if grid_pos.min() < 0:\\n print(\\\"ERROR UNDER!\\\")\\n print(grid_pos.min())\\n print(curr_pool_h.shape)\\n\\n # Perform grid-based pooling with scatter_add-function\\n curr_pool_h = curr_pool_h.scatter_add(0, grid_pos,curr_hidden_repeat)\\n curr_pool_h = curr_pool_h[1:]\\n pool_h.append(curr_pool_h.view(num_ped, -1))\\n\\n pool_h = torch.cat(pool_h, dim=0)\\n pool_h = self.mlp_pool(pool_h)\\n\\n return pool_h\",\n \"def test_propagate_backward_last_hidden(self):\\n nn = NeuralNet(0, 0, '', '', blank=True)\\n nn.create_net(2, 1, 2, 2)\\n nn.eta = 0.1\\n\\n # Override weights to static value for reproducibility\\n for node in nn.layers[2].nodes:\\n node.weights = [0.6, 0.6]\\n\\n for node in nn.layers[3].nodes:\\n node.weights = [1.0, 1.0]\\n\\n # Walk forward\\n nn.propagate_forward([2, 3], test=True)\\n\\n # Walk backward\\n nn.propagate_backward([0])\\n\\n test_weight = nn.layers[-1].nodes[0].weights[0]\\n self.assertEqual(round(test_weight, 4), 0.9901)\",\n \"def init_hidden(self, batch_size: int, device: Device) -> AmbiguousHidden:\\n hidden_zero = torch.zeros(batch_size, self.hidden_size).to(device)\\n\\n if self.rnn_type == \\\"LSTM\\\":\\n return hidden_zero, hidden_zero.clone()\\n else:\\n return hidden_zero\",\n \"def softmax_last_hidden(nr_class, *, exclusive_classes=True, **cfg):\\n width = cfg[\\\"token_vector_width\\\"]\\n return chain(\\n get_last_hidden,\\n flatten_add_lengths,\\n Pooling(mean_pool),\\n Softmax(nr_class, width),\\n )\",\n \"def stateDanglingNodes(self):\\r\\n state = []\\r\\n for i in range(len(self.metaSpikes)):\\r\\n if self.metaSpikes[i].typeSpike == 1:\\r\\n #print (\\\"Inside type 1 \\\\n\\\")\\r\\n #print (\\\"The number of DNs is: \\\" + str(len(self.metaSpikes[i].danglingNodeList)) + \\\"\\\\n\\\")\\r\\n for j in range(len(self.metaSpikes[i].danglingNodeList)):\\r\\n state.append(self.metaSpikes[i].danglingNodeList[j].node.state)\\r\\n\\r\\n # print (\\\"Node in list \\\\n\\\")\\r\\n else:\\r\\n #print (\\\"The number of DTs is: \\\" + str(len(self.metaSpikes[i].danglingTailList)) + \\\"\\\\n\\\")\\r\\n #print (\\\"Inside type 2 \\\\n\\\")\\r\\n for j in range(len(self.metaSpikes[i].danglingTailList)):\\r\\n for k in range(len(self.metaSpikes[i].danglingTailList[j].nodeList)):\\r\\n state.append(self.metaSpikes[i].danglingTailList[j].nodeList[k].state)\\r\\n\\r\\n #print (\\\"The state of dangling nodes is: \\\\n\\\" + str(state) + \\\"\\\\n\\\")\\r\\n #print (\\\"The length of dangling nodes is: \\\\n\\\" + str(len(state)) + \\\"\\\\n\\\") \\r\\n \\r\\n return state\",\n \"def getAbsorbingStates(m):\\n\\t\\n a=[]\\n for r in range(len(m)):\\n if(sum(m[r])==0): a.append(r)\\n return a\",\n \"def get_initial_ff_state(m):\\n return [True] + [False] * (m-1)\",\n \"def get_recent_state(self, current_observation):\\n # This code is slightly complicated by the fact that subsequent observations might be\\n # from different episodes. We ensure that an experience never spans multiple episodes.\\n # This is probably not that important in practice but it seems cleaner.\\n state = [current_observation]\\n idx = len(self.recent_observations) - 1\\n for offset in range(0, self.window_length - 1):\\n current_idx = idx - offset\\n current_terminal = self.recent_terminals[current_idx - 1] if current_idx - 1 >= 0 else False\\n if current_idx < 0 or (not self.ignore_episode_boundaries and current_terminal):\\n # The previously handled observation was terminal, don't add the current one.\\n # Otherwise we would leak into a different episode.\\n break\\n state.insert(0, self.recent_observations[current_idx])\\n while len(state) < self.window_length:\\n state.insert(0, zeroed_observation(state[0]))\\n return state\",\n \"def _get_output_steps_to_beam_indices(self, end_state: Tensor, beam_prev_indices: Tensor) ->List[int]:\\n present_position = int(end_state[1])\\n beam_index = int(end_state[2])\\n beam_indices = torch.jit.annotate(List[int], [])\\n while present_position >= 0:\\n beam_indices.insert(0, beam_index)\\n beam_index = int(beam_prev_indices[present_position][beam_index])\\n present_position = present_position - 1\\n return beam_indices\",\n \"def forward(\\n self,\\n batch_cur_tkids: torch.Tensor,\\n batch_prev_states: Optional[Tuple[List[torch.Tensor], List[torch.Tensor]]] = None,\\n ) -> Tuple[torch.Tensor, Tuple[List[torch.Tensor], List[torch.Tensor]]]:\\n # Use initial hidden states and memory cell initial internal states if `batch_prev_states is None`.\\n if batch_prev_states is None:\\n batch_prev_states = [[None] * self.n_lyr, [None] * self.n_lyr]\\n\\n # Lookup token embeddings and feed to recurrent units.\\n # In shape: (B, S).\\n # Out shape: (B, S, d_hid).\\n rnn_in = self.fc_e2h(self.emb(batch_cur_tkids))\\n\\n # Loop through each layer and gather last hidden states and memory cell last internal states of each layer.\\n batch_cur_states: Tuple[List[torch.Tensor], List[torch.Tensor]] = ([], [])\\n for lyr in range(self.n_lyr):\\n # Fetch memory cell previous internal states of a layer.\\n # Shape: (B, S, n_blk, d_blk).\\n c_0 = batch_prev_states[0][lyr]\\n\\n # Fetch previous hidden states of a layer.\\n # Shape: (B, S, d_hid).\\n h_0 = batch_prev_states[1][lyr]\\n\\n # Get the `lyr`-th RNN layer and the `lyr`-th dropout layer.\\n rnn_lyr = self.stack_rnn[2 * lyr]\\n dropout_lyr = self.stack_rnn[2 * lyr + 1]\\n\\n # Use previous RNN layer's output as next RNN layer's input.\\n # In shape: (B, S, d_hid).\\n # rnn_c_out shape: (B, S, n_blk, d_blk).\\n # rnn_h_out shape: (B, S, d_hid).\\n rnn_c_out, rnn_h_out = rnn_lyr(x=rnn_in, c_0=c_0, h_0=h_0)\\n\\n # Record the last internal states.\\n batch_cur_states[0].append(rnn_c_out[:, -1, :, :].detach())\\n\\n # Record the last hidden states.\\n batch_cur_states[1].append(rnn_h_out[:, -1, :].detach())\\n\\n # Apply dropout to the output.\\n # In shape: (B, S, d_hid).\\n # Out shape: (B, S, d_hid).\\n rnn_h_out = dropout_lyr(rnn_h_out)\\n\\n # Update RNN layer's input.\\n rnn_in = rnn_h_out\\n\\n # Transform hidden states to next token embeddings.\\n # Shape: (B, S, d_emb).\\n z = self.fc_h2e(rnn_h_out)\\n\\n # Calculate similarity scores by calculating inner product over all token embeddings.\\n # Shape: (B, S, V).\\n sim = z @ self.emb.weight.transpose(0, 1)\\n return (sim, batch_cur_states)\",\n \"def process_traffic_lights(self):\\n #DONE find the closest visible traffic light (if one exists within LOOKAHEAD_WPS)\\n if self.init:\\n state = self.get_light_state(0)\\n return -1, TrafficLight.UNKNOWN\\n elif self.ntlwp:\\n state = self.get_light_state(self.ntlwp)\\n # state = TrafficLight.RED\\n return self.ntlwp, state\\n return -1, TrafficLight.UNKNOWN\",\n \"def deconstruct_tail(self):\\n ret = []\\n for ii in range(len(self.__data)):\\n op = self.__data[-ii - 1].deconstruct()\\n if not op:\\n return (self.__data[:len(self.__data) - ii], ret)\\n ret = op + ret\\n return ([], ret)\",\n \"def get_reward_states(self):\\n state1 = State(7, 7)\\n return [state1]\",\n \"def backward(self, dout):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n for l in range(len(self.layers)-1,-1,-1):\\n act_dout = self.activations[l].backward(dout)\\n dout = self.layers[l].backward(act_dout)\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return\",\n \"def get_state_vars(state):\\n x_n = state[0, :] # x_n\\n x_m = np.roll(x_n, -1) # x_{n+1}\\n x_m[-1] += Length # the first one goes ahead by Length\\n dx_n = state[1, :] # dx_n\\n dx_m = np.roll(dx_n, -1) # dx_{n+1}\\n dist = x_m - x_n\\n if (dist <= 0).any():\\n logging.critical(\\\"CRITICAL: Negative distances\\\")\\n return x_n, x_m, dx_n, dx_m, dist\",\n \"def __get_actions(self, state, next_states):\\r\\n val_tok_mov = np.zeros((4, 4))\\r\\n for token_id in range(4):\\r\\n val_tok_mov[token_id] = self.__valid_token_moves(state, next_states[token_id], token_id)\\r\\n\\r\\n actions = np.logical_or.reduce((val_tok_mov[0,:], val_tok_mov[1,:], val_tok_mov[2,:], val_tok_mov[3,:]))\\r\\n\\r\\n return actions, val_tok_mov\",\n \"def get_on_neurons(Fish,state):\\r\\n state_snap= Fish[state,:]\\r\\n \\r\\n label=[]\\r\\n for i in range(len(state_snap)):\\r\\n if state_snap[i]>2:\\r\\n label.append(1)\\r\\n else: \\r\\n label.append(0)\\r\\n return label\",\n \"def state_reset():\\n feat_self = get_self_feat(model, data['img'][0])\\n feat_diff = torch.zeros_like(feat_self)\\n feat_FAR = torch.tensor([0.]).cuda()\\n feat_history = torch.zeros([10]).cuda()\\n\\n return [feat_diff, feat_self, feat_FAR, feat_history]\",\n \"def get_representation(output):\\n\\n # shape: (seq_len, vocab_size)\\n hidden_states = output[1]\\n\\n token_embeddings = torch.stack(hidden_states, dim=0)\\n # remove dimension 1 (batches)\\n token_embeddings = torch.squeeze(token_embeddings, dim=1)\\n # swap dimension 0 and 1\\n token_embeddings = token_embeddings.permute(1, 0, 2)\\n # the last hidden layer output (2+seq_len, 768)\\n hidden_states = [token[-1] for token in token_embeddings]\\n\\n return hidden_states\",\n \"def getRelayStates(self): \\n relayStates = self.values[RELAY_STATES]\\n\\n relay1 = bool(relayStates & 0b0001)\\n relay2 = bool(relayStates & 0b0010)\\n relay3 = bool(relayStates & 0b0100)\\n relay4 = bool(relayStates & 0b1000)\\n\\n return relay1, relay2, relay3, relay4\",\n \"def get_action_outcomes(self, state, action):\\r\\n temp_state = tuple([max(0, min(self.pond_size[i]-1, state[i] + self.action_directions[action][i]))\\r\\n for i in range(2)])\\r\\n return self.transition_lists[temp_state]\",\n \"def forward(self, z, hidden):\\n\\n # Decode\\n l1, hidden = self.decode_RNN(z, hidden)\\n decoded = self.decode_FC(l1) # fully connected layer\\n\\n return decoded, hidden\",\n \"def forward(self, z, hidden):\\n\\n # Decode\\n l1, hidden = self.decode_RNN(z, hidden)\\n decoded = self.decode_FC(l1) # fully connected layer\\n\\n return decoded, hidden\",\n \"def init_hidden_states(self, encoder_out):\\n mean_encoder_out = encoder_out.mean(dim=1)\\n h = self.init_h(mean_encoder_out) # (batch_size, decoder_dim)\\n c = self.init_c(mean_encoder_out)\\n\\n return h, c\",\n \"def _get_state(self):\\n start = self.design.first_unassigned_site\\n return self.target.padded_encoding[\\n start : start + 2 * self._env_config.state_radius + 1\\n ]\",\n \"def extractstates(self, bias=1.0):\\n items = []\\n print(\\\"weights:\\\")\\n print([round(comp.weight, 7) for comp in self.gmm])\\n for comp in self.gmm:\\n val = comp.weight * float(bias)\\n if val > 0.5:\\n for _ in range(int(round(val))):\\n items.append(deepcopy(comp.loc))\\n for x in items: print(x.T)\\n return items\",\n \"def repackage_hidden(h):\\n if type(h) != tuple: # if the hidden state is a variable (see imports)\\n return h.detach() # detach from history\\n else:\\n return tuple(repackage_hidden(v) for v in h)\",\n \"def extract_goal_state(self):\\n time = rospy.get_time()\\n ref_time = time - self.last_time\\n future_time = ref_time + self.update_rate\\n\\n # get state of future time in global trajectory\\n return df.compute_output3D(self.global_solution, self.order, self.time[self.future_index], future_time)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7700957","0.73588395","0.6921017","0.6706472","0.6245193","0.6230705","0.61972374","0.6155109","0.6091971","0.60544163","0.6048018","0.59658885","0.584702","0.58091694","0.58073974","0.57948864","0.5786997","0.5783306","0.5776817","0.57515407","0.57515407","0.5727551","0.57224464","0.57224464","0.5712685","0.57016385","0.5689619","0.5658368","0.5530853","0.5462367","0.54320836","0.53870535","0.5386078","0.53727555","0.5313101","0.5305295","0.5305295","0.5302571","0.52787685","0.52767026","0.5269077","0.5261006","0.52501476","0.52360165","0.5234231","0.5229739","0.52207565","0.52207565","0.52207565","0.51992226","0.51873285","0.5184854","0.5184854","0.51766115","0.5174848","0.5168011","0.51671857","0.5158615","0.5153939","0.51449037","0.5136204","0.5122955","0.51136404","0.51071167","0.5093903","0.50935775","0.5093496","0.5084533","0.5080066","0.5069348","0.5068566","0.505342","0.5053224","0.5040756","0.503026","0.50252014","0.50228894","0.5020149","0.5019771","0.5018693","0.501715","0.4998688","0.49816182","0.49778762","0.49681574","0.496329","0.49616793","0.49571997","0.49502736","0.49425748","0.494113","0.49390075","0.49300584","0.4929686","0.4929686","0.49227127","0.49225","0.49199775","0.4915605","0.49141365"],"string":"[\n \"0.7700957\",\n \"0.73588395\",\n \"0.6921017\",\n \"0.6706472\",\n \"0.6245193\",\n \"0.6230705\",\n \"0.61972374\",\n \"0.6155109\",\n \"0.6091971\",\n \"0.60544163\",\n \"0.6048018\",\n \"0.59658885\",\n \"0.584702\",\n \"0.58091694\",\n \"0.58073974\",\n \"0.57948864\",\n \"0.5786997\",\n \"0.5783306\",\n \"0.5776817\",\n \"0.57515407\",\n \"0.57515407\",\n \"0.5727551\",\n \"0.57224464\",\n \"0.57224464\",\n \"0.5712685\",\n \"0.57016385\",\n \"0.5689619\",\n \"0.5658368\",\n \"0.5530853\",\n \"0.5462367\",\n \"0.54320836\",\n \"0.53870535\",\n \"0.5386078\",\n \"0.53727555\",\n \"0.5313101\",\n \"0.5305295\",\n \"0.5305295\",\n \"0.5302571\",\n \"0.52787685\",\n \"0.52767026\",\n \"0.5269077\",\n \"0.5261006\",\n \"0.52501476\",\n \"0.52360165\",\n \"0.5234231\",\n \"0.5229739\",\n \"0.52207565\",\n \"0.52207565\",\n \"0.52207565\",\n \"0.51992226\",\n \"0.51873285\",\n \"0.5184854\",\n \"0.5184854\",\n \"0.51766115\",\n \"0.5174848\",\n \"0.5168011\",\n \"0.51671857\",\n \"0.5158615\",\n \"0.5153939\",\n \"0.51449037\",\n \"0.5136204\",\n \"0.5122955\",\n \"0.51136404\",\n \"0.51071167\",\n \"0.5093903\",\n \"0.50935775\",\n \"0.5093496\",\n \"0.5084533\",\n \"0.5080066\",\n \"0.5069348\",\n \"0.5068566\",\n \"0.505342\",\n \"0.5053224\",\n \"0.5040756\",\n \"0.503026\",\n \"0.50252014\",\n \"0.50228894\",\n \"0.5020149\",\n \"0.5019771\",\n \"0.5018693\",\n \"0.501715\",\n \"0.4998688\",\n \"0.49816182\",\n \"0.49778762\",\n \"0.49681574\",\n \"0.496329\",\n \"0.49616793\",\n \"0.49571997\",\n \"0.49502736\",\n \"0.49425748\",\n \"0.494113\",\n \"0.49390075\",\n \"0.49300584\",\n \"0.4929686\",\n \"0.4929686\",\n \"0.49227127\",\n \"0.49225\",\n \"0.49199775\",\n \"0.4915605\",\n \"0.49141365\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.758297"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":82998,"cells":{"query":{"kind":"string","value":"Generates matrixes and layers to implement internal processing."},"document":{"kind":"string","value":"def build(self, weight = 0.5):\n \n self.weight = weight\n \n # Defining weighting matrixes\n self.processing_fw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\n self.processing_bw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\n self.processing_last_ht = torch.randn((self._hidden_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\n \n # These will only be applied to the intermediate hidden states\n self.linear_fw = nn.Linear(self._seqlen - 1, 1).to(self.device)\n self.linear_bw = nn.Linear(self._seqlen - 1, 1).to(self.device)\n \n self.compression = torch.randn((self._expansion_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\n \n if self._activation_fn == 'tanh' or isinstance(self._activation_fn, torch.nn.modules.activation.Tanh):\n self._activation_fn = nn.Tanh()\n elif self._activation_fn == 'sigmoid' or isinstance(self._activation_fn, torch.nn.modules.activation.Sigmoid):\n self._activation_fn = nn.Sigmoid()\n elif self._activation_fn == 'leaky ReLU' or isinstance(self._activation_fn, torch.nn.modules.activation.LeakyReLU):\n self._activation_fn = nn.LeakyReLU()\n else:\n raise ValueError('Non-linear activation function must be \"tanh\", \"sigmoid\" or \"leaky ReLU\"')\n \n # Passing it onto the relevant device\n self._activation_fn = self._activation_fn.to(self.device)"},"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 assembleMatrices(self):\n # All nodes informations\n self.aircraftNodesPoints = []\n self.aircraftMassPoints = []\n self.aircraftMassDistances = []\n self.aircraftSegmentsLengths = []\n self.aircraftNodesNames = []\n self.aircraftInitNodesAreas = []\n self.aircraftNodesA = []\n self.aircraftNodesIy = []\n self.aircraftNodesIz = []\n self.aircraftNodesJ = []\n # More general information\n self.aircraftConnectedNodes = []\n self.aircraftNonRotatingNodes = []\n\n self.computeProportionFuselage()\n self.computeProportionWings()\n\n # adds fulseage infos to matrices if there is one\n if self.nFuselage > 0:\n self.aircraftNodesPoints.append(self.fs_m_points[0])\n # Assumption is made that for a fuselage section, its cog is\n # aligned with the section center.\n self.aircraftMassPoints.append(self.fs_m_points[0])\n self.aircraftMassDistances.append(np.zeros((len(self.fs_m_points[0]),3)))\n self.aircraftSegmentsLengths.append(self.fs_m_distanceBetweenPoints[0])\n self.aircraftNodesNames.append(self.fs_m_pointsName[0])\n self.aircraftInitNodesAreas.append(self.fs_m_pointsInitArea[0])\n self.aircraftNodesA.append(self.fs_m_pointsA[0])\n self.aircraftNodesIy.append(self.fs_m_pointsIy[0])\n self.aircraftNodesIz.append(self.fs_m_pointsIz[0])\n self.aircraftNodesJ.append(self.fs_m_pointsJ[0])\n logger.debug('\\n')\n for i in range(self.nWings):\n self.aircraftNodesPoints.append(self.ws_me_points[i])\n self.aircraftMassPoints.append(self.ws_ma_points[i])\n self.aircraftMassDistances.append(self.ws_ma_distance[i])\n self.aircraftSegmentsLengths.append(self.ws_me_distances[i])\n # logger.debug(i)\n # logger.debug(self.ws_me_distances)\n # logger.debug(self.aircraftSegmentsLengths)\n self.aircraftNodesNames.append(self.ws_me_pointsName[i])\n self.aircraftInitNodesAreas.append(self.ws_me_pointsInitArea[i])\n self.aircraftNodesA.append(self.ws_me_pointsA[i])\n self.aircraftNodesIy.append(self.ws_me_pointsIy[i])\n self.aircraftNodesIz.append(self.ws_me_pointsIz[i])\n self.aircraftNodesJ.append(self.ws_me_pointsJ[i])\n self.computeMass()","def generate_image_matrices():\r\n for i in range(int(number_of_matrices.get())):\r\n clear_space()\r\n populate_image_lists()\r\n randomly_select_images()\r\n get_image_data()\r\n grid_frame = Image.new(\"RGB\", (matrix_x_pix, matrix_y_pix), \"white\")\r\n image_index = 0\r\n for j in range(matrix_x):\r\n for k in range(matrix_y):\r\n img = Image.open(images_total[image_index])\r\n grid_frame.paste(img, (padding + (j * (padding + image_x)),\r\n padding + (k * (padding + image_y))))\r\n image_index += 1\r\n\r\n save_path = (os.path.join(dir_path, \"outputs\\\\\") +\r\n number_of_images_a.get() + \"a\" +\r\n number_of_images_b.get() + \"b_img\" + str(i) + \".png\")\r\n grid_frame.save(save_path, \"PNG\")","def make_all(self):\n # General matrices #\n self.tsv_seq_to_concepts()\n self.tsv_seq_to_names()\n self.list_sequence_concept()\n # Only in the with 'samples' case #\n if self.a.abundances: self.tsv_samples_to_names()\n if self.a.abundances: self.biom_output()\n # Graphical outputs #\n self.per_seq_dot_files()\n if self.a.abundances: self.per_sample_dot_files()","def _derive_transformation_matrices(self):\n\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\n if self._primaries is not None and self._whitepoint is not None:\n npm = normalised_primary_matrix(self._primaries,\n self._whitepoint)\n\n self._derived_RGB_to_XYZ_matrix = npm\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)","def build(self):\n self.build_inputs()\n self.build_word_embeddings()\n self.build_encoder()\n self.build_fc()\n self.build_loss()\n self.build_global_step()","def build_matrix(self):\n self.lb_make = LabelEncoder()\n self.lb_make.fit(self.Y_train)\n tokenizer = Tokenizer(num_words=2000)\n x_array_train = numpy.asarray(self.train['text'])\n x_array_test = numpy.asarray(self.test['text'])\n tokenizer.fit_on_texts(x_array_train)\n x_train_matrix = tokenizer.texts_to_matrix(x_array_train, mode='count')\n x_test_matrix = tokenizer.texts_to_matrix(x_array_test, mode='count')\n y_train_numbers = self.lb_make.transform(self.Y_train)\n y_test_numbers = self.lb_make.transform(self.Y_test)\n y_train_matrix = keras.utils.to_categorical(y_train_numbers, 3)\n y_test_matrix = keras.utils.to_categorical(y_test_numbers, 3)\n self.tokenizer = tokenizer\n return x_train_matrix, x_test_matrix, y_train_matrix, y_test_matrix","def CreateMatrix(self) -> BaseMatrix:","def CreateMatrix(self) -> BaseMatrix:","def build_graph(self):\n self.__create_placeholders()\n self.__create_encoder()\n self.__create_latent()\n self.__create_decoder()\n self.__create_loss()\n self.__create_generate()\n self.__create_reconstruct()\n self.__create_optimizer()\n self.__create_summary()","def build_graph(self):\n\t\tself._create_placeholders()\n\t\tself._create_embedding()\n\t\tself._create_recurrent_layers()\n\t\tself._create_de_embedding()\n\t\tself._create_loss()\n\t\tself._create_optimizer()\n\t\tself._create_summaries()","def create_matrices(self):\n debut = time.process_time()\n\n x = np.arange(0, self.axe_X)\n y = np.arange(0, self.axe_Y)\n xv, yv = np.meshgrid(x, y)\n\n print(\"\\nmatrix creation estimation time: %.1fs\" % (1e-6*self.axe_X*self.axe_Y))\n\n img_matrix_x, img_matrix_y = self.find_position(xv, yv)\n\n fin = time.process_time()\n print(\"matrix created in time: %.1f s\" % (fin-debut))\n return img_matrix_x, img_matrix_y","def _generate_network_initialization(self, graph, memory_manager):\n\n # TODO: To be changed if we want to support multiple outputs\n output_buffer_name = graph.outputs[0].name\n\n ops_to_ignore = ['Reshape', 'Mul']\n\n buffers_allocated = []\n\n buffer_declaration = \"\"\n buffer_declaration += \" pico_cnn::naive::Tensor **kernels;\\n\"\n buffer_declaration += \" pico_cnn::naive::Tensor **biases;\\n\"\n\n constructor_code = \"\"\n #constructor_code += \"Network::Network() {\\n\\n\"\n\n num_layers = 0\n num_kernels = 0\n num_biases = 0\n\n for node in graph.nodes:\n \"\"\"Do not count the reshape layers as the input tensor will only define the dimensions\"\"\"\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n num_layers += 1\n for num, input in enumerate(node.input_tensors):\n if input in buffers_allocated:\n continue\n else:\n tensor = node.input_tensors[input]\n buffers_allocated.append(input)\n if len(tensor.shape) == 1:\n num_biases += 1\n else:\n num_kernels += 1\n\n \"\"\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\"\"\"\n constructor_code += \" kernels = new pico_cnn::naive::Tensor*[{}]();\\n\".format(num_kernels)\n constructor_code += \" biases = new pico_cnn::naive::Tensor*[{}]();\\n\\n\".format(num_biases)\n\n pos = -1\n pos_kernel = -1\n pos_bias = -1\n\n buffers_allocated.clear()\n\n \"\"\"Iterate over all nodes in the graph and generate the corresponding allocation code.\"\"\"\n for node_id, node in enumerate(graph.nodes):\n\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n pos += 1\n\n buffer_declaration += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n constructor_code += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n\n # Allocate memory for kernels and biases\n buffer_declaration += \" // Inputs\\n\"\n constructor_code += \" // Inputs\\n\"\n for num, input in enumerate(node.input_tensors):\n\n if node.op_type in ops_to_ignore:\n continue\n\n if input in buffers_allocated:\n continue\n else:\n buffers_allocated.append(input)\n\n tensor = node.input_tensors[input]\n if len(tensor.shape) == 1:\n pos_bias += 1\n else:\n pos_kernel += 1\n\n buffer = memory_manager.get_buffer(graph, input)\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"KernelAllocation\")\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \" // Outputs\\n\"\n constructor_code += \" // Outputs\\n\"\n for num, output in enumerate(node.outputs):\n\n buffer = memory_manager.get_buffer(graph, output)\n\n if output == output_buffer_name:\n buffer_declaration += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n constructor_code += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n continue\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"OutputAllocation\")\n impl = functionality[0].create(buffer)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \"\\n\\n\"\n constructor_code += \"\\n\\n\"\n\n #constructor_code += \"}\\n\"\n\n self.buffer_declaration = buffer_declaration\n self.constructor_code = constructor_code","def create_training_matrices(experiment, sample_times):\n # Labels:\n location_labels = read_location_labels(experiment)\n locations = get_location_of_persons_at_samples(location_labels, sample_times, experiment)\n\n p1_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P1\")\n p2_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P2\")\n p3_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P3\")\n p4_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P4\")\n\n print(p1_scene_features.loc[0]['predictions'].shape[0])\n print(len(p1_scene_features['predictions'][0]))\n data = {\n \"P1\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P2\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P3\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P4\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0]))\n }\n\n for index, loc_label in enumerate(locations):\n t = loc_label[0]\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P1_eyetracker\")\n p1 = np.mean(p1_scene_features[p1_scene_features['timestamp'].between(t_et - sample_step/2, t_et + sample_step/2)]['predictions'].as_matrix(), axis=0)\n\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P2_eyetracker\")\n p2 = np.mean(\n p2_scene_features[p2_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P3_eyetracker\")\n p3 = np.mean(\n p3_scene_features[p3_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P4_eyetracker\")\n p4 = np.mean(\n p4_scene_features[p4_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n data[\"P1\"][index, 0] = t\n data[\"P1\"][index, 1:-1] = p1\n data[\"P1\"][index, -1] = loc_label[1]\n\n data[\"P2\"][index, 0] = t\n data[\"P2\"][index, 1:-1] = p2\n data[\"P2\"][index, -1] = loc_label[2]\n\n data[\"P3\"][index, 0] = t\n data[\"P3\"][index, 1:-1] = p3\n data[\"P3\"][index, -1] = loc_label[3]\n\n data[\"P4\"][index, 0] = t\n data[\"P4\"][index, 1:-1] = p4\n data[\"P4\"][index, -1] = loc_label[4]\n\n return data","def initParams(self):\n sizes = [self.inputDim]+self.layerSizes+[self.outputDim]\n scales = [np.sqrt(6)/np.sqrt(n+m) for n,m in zip(sizes[:-1],sizes[1:])]\n self.stack = [[np.random.rand(m,n)*2*s-s,np.zeros((m,1))] \\\n for n,m,s in zip(sizes[:-1],sizes[1:],scales)]\n self.hActs_M = [cm.empty((s,self.maxBatch)) for s in sizes]\n\n if self.train:\n # Now assuming that all layers are the same size\n self.grad = [[cm.empty(w.shape),cm.empty(b.shape)] for w,b in self.stack]\n self.deltasC_M = cm.empty((self.outputDim,self.maxBatch))\n self.deltasOut_M = cm.empty((sizes[1],self.maxBatch)) \n self.deltasIn_M = cm.empty((sizes[1],self.maxBatch)) \n self.tmpGrad_M = cm.empty((self.layerSize,self.maxBatch))\n \n # Allocate memory once here and reuse\n # Store probs\n self.probs_M = cm.empty((self.outputDim,self.maxBatch))\n # Store col max\n self.rowVec_M = cm.empty((1,self.maxBatch))\n \n self.stack = [[cm.CUDAMatrix(w),cm.CUDAMatrix(b)]\n for w,b in self.stack]\n\n if self.temporalLayer > 0:\n # dummy bias used for temporal layer\n dummy = cm.empty((1,1))\n dummy.assign(0.0)\n\n scale = np.sqrt(6)/np.sqrt(self.layerSize*2)\n wtf = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\n self.layerSize)-scale)\n wtb = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\n self.layerSize)-scale)\n self.stack.append([wtf,dummy])\n self.stack.append([wtb,dummy])\n\n # forward and backward activations for temporal layer\n self.hActsFor_M = cm.empty((self.layerSize,self.maxBatch))\n self.hActsBack_M = cm.empty((self.layerSize,self.maxBatch))\n\n if self.train:\n dwtf = cm.empty(wtf.shape)\n self.grad.append([dwtf,dummy])\n dwtb = cm.empty(wtb.shape)\n self.grad.append([dwtb,dummy])\n\n self.tmpGradBack_M = cm.empty((self.layerSize,self.maxBatch))\n self.deltasFor_M = cm.empty((self.layerSize,self.maxBatch))\n self.deltasBack_M = cm.empty((self.layerSize,self.maxBatch))","def build(self):\n self.build_inputs()\n self.build_image_embeddings()\n self.build_seq_embeddings()\n self.build_encoder()\n self.build_prediction_model()\n self.setup_encoder_initializer()\n self.setup_global_step()\n self.list_trainable_variables()","def compile(self):\n for layer in self.layers:\n layer._Dense__load()","def build(self):\n self.build_inputs()\n self.image_embeddings = self.build_image_embeddings(self.images)\n self.seq_embeddings = self.build_seq_embeddings(self.input_seqs)\n self.build_model()\n self.setup_inception_initializer()\n self.setup_global_step()","def newMatrix(self):\n self.matrix = makeMatrix()\n for row in range(self.matrix.getHeight()):\n for column in range(self.matrix.getWidth()):\n self.canvasGrid[row][column].draw(self.matrix[row][column])","def make_matrix():\n\n # this imports category, category, data, text, pptx_data\n\n if use_test_data:\n # make a test matrix using create_test_matrix\n m = matrixfuncs.create_test_matrix()\n\n else:\n # make a matrix by connecting to Slides! and connecting to a data\n # table.\n import transformations.utils.slidesconf as slidesconf\n from Forgetdata.Matrix import ConnectionDefinition\n conn = ConnectionDefinition()\n conn.ConnectionString = mtd_filepath # set at top of file\n conn.Name = \"Test\"\n conn.Provider = \"SPSS MTD File\"\n liveConnection = slidesconf.connect(conn.ConnectionString,\n name=conn.Name,\n provider_name=conn.Provider)\n\n m = liveConnection[table_selected]\n\n x = tr.MatrixManipulator(m)\n matrixfuncs.printMatrix(m)\n\n for c in m[0]:\n c.TopMember.Label = c.TopMember.Label.encode('ascii', 'ignore')\n\n return m, x","def generate_mxp_graph(model_name, activations, stats, first_node_name, last_node_name, io_info,\n input_type, ignore_strides=False, inline_depthwise=False, verbose=False):\n network = {}\n network['layers'] = []\n network['test_input'] = None\n network['test_output'] = None\n network['scale'] = 1.0\n\n model = onnx.load(model_name)\n nodes = model.graph.node\n inits = model.graph.initializer\n\n idx = get_node_index(nodes, first_node_name)\n if idx == None:\n if verbose:\n print('{} does not exist\\nopen {} in Netron + check spelling'.format(first_node_name, mname))\n assert(idx != None)\n\n last_idx = get_node_index(nodes, last_node_name)\n if last_idx == None:\n if verbose:\n print('{} does not exist\\nopen {} in Netron + check spelling'.format(last_node_name, mname))\n assert(last_idx != None)\n\n while True:\n node = nodes[idx]\n if verbose:\n print(node.name, node.op_type)\n src_node = get_node_source(nodes, node.input[0])\n if src_node == None:\n input_id = node.input[0]\n else:\n input_id = src_node.output[0]\n output_id = node.output[0]\n\n\n if len(network['layers']) == 0:\n previous = None\n else:\n previous = network['layers'][-1]\n for layer in network['layers']:\n if layer['output_id'] == input_id:\n previous = layer\n\n input_shapes, output_shapes = get_shapes(activations, stats, node)\n assert len(output_shapes) == 1, \"Multi-output nodes not supported\"\n output_shape = output_shapes[0]\n if node.op_type == \"Conv\":\n c, m, n = input_shapes[0]\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\n assert(get_attr(node, 'pads') == None or not any(get_attr(node, 'pads')))\n\n group = get_attr(node, 'group')\n strides = np.asarray(get_attr(node, 'strides')).tolist()\n dilations = np.asarray(get_attr(node, 'dilations')).tolist()\n if not group:\n group = 1\n if not strides:\n strides = [1, 1]\n if not dilations:\n dilations = [1, 1]\n\n use_strided = 0\n assert(strides == [1, 1] or strides == [2, 2] or strides == [4, 4])\n\n if DO_STRIDES and not ignore_strides:\n if (strides[0] > 1 or strides[1] > 1) and group == 1: # TODO handle depthwise as well\n assert(previous['output_size'] == int(np.prod(input_shapes[0])))\n use_strided = 1\n previous['output_strides'] = strides\n if verbose:\n print('adding output strides to previous node')\n\n m = m + (m % strides[0])\n n = n + (n % strides[1])\n if int(np.prod(input_shapes[0])) != int(c*m*n):\n if verbose:\n print('adjusting size for strided maps')\n previous['output_size'] = int(c*4*m//strides[0]*n//strides[1])\n previous['output_shape'] = (c*4,m//strides[0],n//strides[1])\n\n w = get_tensor(inits, node.input[1])\n kernels, channels, _, _ = w.shape\n if len(node.input) == 3:\n b = get_tensor(inits, node.input[2])\n\n conv_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(c*m*n),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels * group,\n 'kernels': kernels,\n 'kernel_shape': kernel_shape,\n 'dilations': dilations,\n 'strides': strides,\n 'group': group,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n 'use_cvi': 0,\n 'use_depthwise': 0,\n 'use_strided': use_strided,\n \"biases\": [],\n \"weights\": [],\n \"sublayers\": [],\n }\n\n w = w.flatten().tolist()\n conv_layer['weights'] = base64.b64encode(struct.pack(\"f\"*len(w), *w)).decode()\n\n if len(node.input) == 3:\n b = b.flatten().tolist()\n else:\n b = [0 for _ in range(kernels)]\n conv_layer['biases'] = base64.b64encode(struct.pack(\"f\"*len(b), *b)).decode()\n\n network['layers'].append(conv_layer)\n\n elif node.op_type == \"Gemm\":\n w = get_tensor(inits, node.input[1])\n output_size, input_size = w.shape\n\n if len(node.input) == 3:\n b = get_tensor(inits, node.input[2])\n\n gemm_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(np.prod(input_shapes[0])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape': output_shape,\n 'gemm_input_size': input_size,\n 'gemm_output_size': output_size,\n 'input_id': input_id,\n 'output_id': output_id,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"biases\": [],\n \"weights\": [],\n \"sublayers\": [],\n }\n\n w = w.flatten().tolist()\n gemm_layer['weights'] = base64.b64encode(struct.pack(\"f\"*len(w), *w)).decode()\n\n if len(node.input) == 3:\n b = b.flatten().tolist()\n else:\n b = [0 for _ in range(output_size)]\n gemm_layer['biases'] = base64.b64encode(struct.pack(\"f\"*len(b), *b)).decode()\n network['layers'].append(gemm_layer)\n\n elif node.op_type in multipath_nodes:\n node_inputs = get_previous_nodes(nodes, node)\n shapes = input_shapes\n\n if node.op_type == \"Sum\":\n assert(all([x == shapes[0] for x in shapes[1:]]))\n elif node.op_type == \"Concat\":\n assert(all([x[1:] == shapes[0][1:] for x in shapes[1:]]))\n\n buf = node_inputs[0].name\n if node.op_type == \"Concat\":\n buf = output_id\n\n buffer_offset = 0\n for n, node_input in enumerate(node_inputs):\n noutput = node_input.output[0]\n for l, layer in enumerate(network['layers']):\n if layer['output_id'] == noutput: # if layer pointing to this node\n network['layers'][l]['output_id'] = buf # rename layer's output\n network['layers'][l]['buffer_offset'] = buffer_offset # and offset appropriately\n if layer['input_id'] == noutput:\n network['layers'][l]['input_id'] = buf #TODO\n\n buffer_offset += int(np.prod(input_shapes[n]))\n\n if node.op_type == \"Sum\":\n channels, m, n = shape3d(output_shape)\n sum_layer = {\n 'op_type': \"Sum\",\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': node_inputs[0].name,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n 'num_inputs': len(node.input),\n \"sublayers\": [],\n }\n network['layers'].append(sum_layer)\n\n elif node.op_type == \"Identity\":\n shapes = input_shapes\n\n channels, m, n = shape3d(output_shape)\n identity_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n }\n network['layers'].append(identity_layer)\n\n elif node.op_type == \"LRN\":\n shapes = input_shapes\n channels, m, n = shape3d(output_shape)\n lrn_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'alpha': get_attr(node, 'alpha'),\n 'beta': get_attr(node, 'beta'),\n 'bias': get_attr(node, 'bias'),\n 'size': get_attr(node, 'size'),\n 'scale': 1.0,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n }\n network['layers'].append(lrn_layer)\n\n elif node.op_type == \"Scale\":\n scale_sublayer = {\n 'op_type': 'Scale',\n 'name': node.name,\n \"use_replay\": 1,\n 'scale': get_attr(node, 'scale'),\n }\n previous['sublayers'].append(scale_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type in [\"GlobalAveragePool\", \"GlobalMaxPool\"]:\n assert(previous['n'] == previous['m'])\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\n strides = np.asarray(get_attr(node, 'strides')).tolist()\n pads = pads6(node)\n pool_sublayer = {\n 'op_type': node.op_type.replace('Global', ''),\n 'name': node.name,\n 'use_replay': 0,\n 'kernel_shape': [previous['m'], previous['n']],\n 'strides': [previous['m'], previous['n']],\n 'pads': pads,\n }\n previous['sublayers'].append(pool_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n previous['output_shape'] = (output_shape)\n\n elif node.op_type in [\"MaxPool\", \"AveragePool\"]:\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\n\n if node.op_type == \"AveragePool\": #TODO quick fix for tf average pool quirk\n if kernel_shape[0] * kernel_shape[1] == previous['m'] * previous['n']:\n kernel_shape = [previous['m'], previous['n']]\n strides = np.asarray(get_attr(node, 'strides')).tolist()\n if strides is None:\n strides = [ 1 for _ in kernel_shape]\n pads = pads6(node)\n pool_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'kernel_shape': kernel_shape,\n 'strides': strides,\n 'pads': pads,\n }\n previous['sublayers'].append(pool_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n previous['output_shape'] = (output_shape)\n elif node.op_type == \"PRelu\":\n slope = get_tensor(inits, node.input[1])\n slope = slope.flatten().tolist()\n prelu_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'slope': slope,\n }\n previous['sublayers'].append(prelu_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"LeakyRelu\":\n alpha = get_attr(node, 'alpha')\n if alpha is None:\n alpha = .01\n leaky_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'alpha': alpha\n }\n previous['sublayers'].append(leaky_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"Relu\":\n relu_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n }\n previous['sublayers'].append(relu_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"Clip\":\n clip_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'min': float(get_tensor(inits,node.input[1])),\n 'max': float(get_tensor(inits,node.input[2])),\n }\n previous['sublayers'].append(clip_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"Pad\":\n pads = pads6(get_tensor(inits,node.input[1]).tolist())\n value = int(get_tensor(inits,node.input[2]))\n if value < -1:\n value = -1\n if value > 1:\n value = 1\n pad_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'value': value,\n 'pads': pads,\n }\n previous['sublayers'].append(pad_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n previous['output_shape'] = (output_shape)\n elif node.op_type in [\"Add\", \"Mul\", \"Sub\", \"Div\"]:\n\n skip = False\n if node.op_type == \"Mul\":\n next_nodes = get_node_inputs(nodes, node.output[0])\n if node.name == nodes[-1].name:\n if verbose:\n print('removing final scale node')\n skip = True\n\n elif previous['op_type'] in [\"LRN\"]:\n if verbose:\n print('skipping mul after lrn')\n array = get_tensor(inits, node.input[1])\n if array is None:\n array = get_tensor(inits, node.input[0])\n previous['scale'] = float(array[0])\n print('skipping mul after lrn', previous['scale'], previous['input_id'], previous['output_id'])\n\n skip = True\n\n elif next_nodes[0].op_type in [\"Softmax\"]:\n if verbose:\n print('skipping mul before softmax')\n skip = True\n\n array = get_tensor(inits, node.input[1])\n if array is None:\n array = get_tensor(inits, node.input[0])\n c = activations[node.input[1]].shape[1]\n else:\n c = input_shapes[0][0]\n\n if node.op_type == \"Add\": # TODO for scalar Add\n dims = len(np.squeeze(array).shape)\n if dims == 0:\n array = np.ones((c, 1)) * array\n\n dims = len(np.squeeze(array).shape)\n if c == 1 and dims == 0:\n dims = 1\n\n array = array.flatten().tolist()\n # force_broadcast_2 = False\n # if force_broadcast_2:\n # # if c != 1 and dims == 0:\n # if c != 1 and dims == 0 and node.op_type != \"Mul\": # TODO forcing to broadcast 2 not broadcast 3\n # dims = 1\n # array = [array[0] for _ in range(c)]\n\n if not skip:\n arithmetic_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'dims': dims,\n 'array': array,\n }\n previous['sublayers'].append(arithmetic_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type in [\"Abs\", \"Max\", \"Mean\", \"Min\", \"Neg\", \"Not\"]:\n unary_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n }\n previous['sublayers'].append(unary_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n\n elif node.op_type == \"Reshape\":\n dims = get_tensor(inits, node.input[1])\n\n if len(dims) == 4 and dims[-1] == 2:\n idx += 6\n node = nodes[idx]\n output_id = node.output[0]\n _, output_shapes = get_shapes(activations, stats, node)\n output_shape = output_shapes[0]\n channels, m, n = shape3d(output_shape)\n reorg_layer = {\n 'op_type': \"Reorg\",\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape': output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n \"stride\": int(dims[-1]),\n }\n network['layers'].append(reorg_layer)\n else:\n previous['output_id'] = output_id\n\n elif node.op_type in [\"Flatten\",'Cast']:\n previous['output_id'] = output_id\n elif node.op_type == \"Resize\":\n scales = get_tensor(inits, node.input[2])\n assert(scales[0] == 1 and scales[1] == 1)\n scale = float(scales[2])\n mode = get_attr(node, 'mode').decode()\n assert(mode == 'nearest' or mode == 'linear')\n shapes = input_shapes[:1]\n channels, m, n = shape3d(output_shape)\n in_size= [d for d in one_elem(input_shapes)[1:]]\n replay = 0 if in_size == [1,1] else 1\n resize_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': replay,\n 'input_size': int(np.prod(one_elem(input_shapes))),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'mode' :mode,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n 'scale': [float(scales[2]),float(scales[3])],\n }\n network['layers'].append(resize_layer)\n elif node.op_type == \"ArgMax\":\n input_shape = one_elem(input_shapes)\n channels, m, n = shape3d(input_shape)\n argmax_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n 'scale': [float(scales[2]),float(scales[3])],\n }\n network['layers'].append(argmax_layer)\n\n elif node.op_type == \"Softmax\":\n prev = get_previous_nodes(nodes, node)[0]\n if prev.op_type == \"Mul\":\n scale = get_tensor(inits, prev.input[1])\n scale = scale.flatten().tolist()\n else:\n scale = [1.0]\n if len(scale) > 1:\n raise NotImplementedError(\"Broadcast scale not implemented for softmax\")\n\n shapes = input_shapes\n channels, m, n = shape3d(output_shape)\n softmax_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n 'scale': scale,\n 'size': len(scale),\n }\n network['layers'].append(softmax_layer)\n\n # softmax_sublayer = {u'op_type': u'Softmax', 'scale': 1.0}\n # previous['sublayers'].append(softmax_sublayer)\n # previous['output_id'] = output_id\n # print('warning SOFTMAX ignored!... fine if last layer and sorting outputs')\n\n elif node.op_type == \"Transpose\":\n shapes = input_shapes\n\n channels, m, n = shape3d(output_shape)\n permutation =[p-1 for p in get_attr(node, 'perm')[1:]]\n transpose_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n 'permutation':permutation,\n \"sublayers\": [],\n }\n network['layers'].append(transpose_layer)\n else:\n raise RuntimeError('Unknown node type:{} '.format(node.op_type))\n\n idx += 1\n if idx > last_idx:\n break\n\n unsigned_network_inputs = input_type == np.uint8\n\n if CVI_1x1:\n network = mxp_gemm_to_conv(network)\n\n network = mxp_set_replay(network, io_info)\n network = mxp_set_cvi(network)\n network = mxp_set_unsigned(network, unsigned_network_inputs)\n\n if inline_depthwise:\n network = mxp_inline_depthwise(network)\n\n network = mxp_describe_layers(network)\n network = mxp_number_buffers(network)\n buffers = mxp_size_buffers(network)\n network = mxp_number_sublayers(network)\n\n network['num_layers'] = len(network['layers'])\n network['buffers'] = buffers\n\n return network","def generate(self):\n self.generate_points()\n self.generate_edges()","def create_matrix(self):\n import random\n random.seed()\n #pecas_disponiveis = [\"escudo\", \"espada\", \"espada_dupla\", \"machadinha\", \"adaga\", \"punhais\"]\n pecas_disponiveis = [\"escudo\", \"punhais\", \"espada_dupla\", \"machadinha\", \"adaga\"]\n x_start, y_start = 10, self.running.top_bar\n x, y = x_start, y_start\n anterior_esq = [None] * self.running.linhas\n anterior_acima = None\n\n for i in range(self.running.colunas):\n coluna = []\n for j in range(self.running.linhas):\n possiveis_escolhas = pecas_disponiveis.copy()\n if possiveis_escolhas.count(anterior_esq[j]) > 0: possiveis_escolhas.remove(anterior_esq[j])\n if possiveis_escolhas.count(anterior_acima) > 0 : possiveis_escolhas.remove(anterior_acima)\n \n e_type = random.choice(possiveis_escolhas)\n tile = Tile(self.game, x, y, e_type)\n coluna.append(tile)\n self.running.game_images.append(tile.game_image)\n y += self.running.y_space\n anterior_esq[j] = e_type\n anterior_acima = e_type\n self.running.tabuleiro.append(coluna)\n x += self.running.x_space\n y = y_start\n return","def create_dev_matrix(self):\n if os.path.exists(self.dev_matrix_h5_path):\n print(\"[LOGGING]: \" + self.dev_matrix_h5_path + \" exists!\")\n return\n\n with h5py.File(self.dev_matrix_h5_path, 'w') as f:\n\n for mode in ['train', 'test']:\n for device in ['a', 'b', 'c']:\n grp = f.create_group(mode + '/' + device)\n grp['data'], grp['label'] = self.extract_npy(mode=mode, devices=device)\n # add parallel data as separate device p\n grp = f.create_group(mode + '/p')\n grp['data'], grp['label'] = self.extrac_para_npy(mode=mode)\n\n # add neg parallel data as device A\n grp = f.create_group(mode + '/A')\n grp['data'], grp['label'] = self.extract_neg_para_npy(mode=mode)\n f.close()","def _generate_adjacency_matrices(self):\n self.adj_matrices = dict()\n mes = []\n args = []\n for metaedge in self.metaedges:\n mes.append(metaedge)\n args.append(self._prepare_parallel_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\n front_num=0)\n for metaedge, matrix in zip(mes, res):\n self.adj_matrices[metaedge] = matrix","def output_rule_feature_matrices():\n with open(config.data_path + config.sentiment_seed, 'rb') as input_file:\n sentiment_dict = pickle.load(input_file)\n seed_sentiments = set(sentiment_dict.keys())\n \n for i in range(len(config.file_names)):\n if i is 5:\n print('processing ', config.file_names[i])\n fname = config.file_names[i]\n feature_x, feature_y, opinion_x, opinion_y = text_to_matrix(\n fname, seed_sentiments)\n feature_x = np.transpose(feature_x)\n opinion_x = np.transpose(opinion_x)\n with open('../results/' + fname + '_rule_feature_matrix.pickle', 'wb') as f:\n pickle.dump(feature_x, f)\n with open('../results/' + fname + '_rule_opinion_matrix.pickle', 'wb') as f:\n pickle.dump(opinion_x, f)\n\n with open('../results/' + fname + '_feature_label.pickle', 'wb') as f:\n pickle.dump(feature_y.ravel(), f)\n with open('../results/' + fname + '_opinion_label.pickle', 'wb') as f:\n pickle.dump(opinion_y.ravel(), f)","def get_linear_discrete_matrices(self):\n\n vf_op, vb_op = get_operating_point_inputs(self.operating_point[1], self.model_type)\n if self.model_type == ModelType.EASY:\n At, Bt, Vf_op, Vd_op = getLinearizedMatrices(self.model_type, self.operating_point[0:6], vf_op, vb_op)\n elif self.model_type == ModelType.GYROMOMENT:\n At, Bt = get_gyro_matrices(self.operating_point, self.operating_point[6] / mc.K_f, vf_op, vb_op)\n if self.model_type == ModelType.EASY:\n Ct = np.array([[1, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0]])\n Dt = np.array([[0, 0],\n [0, 0],\n [0, 0]])\n elif self.model_type == ModelType.GYROMOMENT:\n if self.nOutputs == 3:\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0]])\n Dt = np.array([[0, 0],\n [0, 0],\n [0, 0],\n [0, 0],\n [0, 0]])\n elif self.nOutputs == 5:\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 1, 0],\n [0, 0, 0, 0, 0, 0, 0, 1]])\n Dt = np.array([[0, 0],\n [0, 0],\n [0, 0],\n [0, 0],\n [0, 0]])\n\n Ak, Bk, Ck, Dk = discretize_linear_state_space(At, Bt, Ct, Dt, self.timeStep)\n return Ak, Bk, Ck, Dk","def make_input_materials(self) :\n # 1 5 1 MATERIAL 1 (arbitrary line, i think) \n # 1.4493e+00 9.9000e-03 7.9000e-03 1. 0. 0. 7.9000e-03 1.\n # 3.8070e-01 1.0420e-01 1.6920e-01 0 1.5100e-02 0. 1.6920e-01 1.\n self.input_materials = \"\"\n number_mats = len(self.core.pattern)+1\n a = self.core.assemblies\n for i in range(0, number_mats-1) :\n # Row 1: description.\n self.input_materials += \" \" + str(i+1) + \" 5 1 MATERIAL \" + \\\n str(i+1) + \" (\" + \\\n a[i].model + \", \" + \\\n str(a[i].enrichment) + \" w/o, \" + \\\n str(a[i].burnup) + \" MWd/kg)\\n\" \n # Rows 2 and 3.\n D1,D2,A1,A2,F1,F2,S12 = a[i].get_constants()\n d = np.array([[D1,A1,F1,1.0,0.0,0.0,F1,1.0],[D2,A2,F2,0.0,S12,0.0,F2,1.0]])\n for j in range(0, 2) :\n for k in range(0, 8) :\n self.input_materials +='%12.4e' %(d[j,k])\n self.input_materials += '\\n'\n \n a = self.core.reflector\n # Row 1: description.\n self.input_materials += \" \" + str(number_mats) + \" 5 1 MATERIAL \" + \\\n str(number_mats) + \" (REFLECTOR) \\n\" \n # Rows 2 and 3.\n D1,D2,A1,A2,F1,F2,S12 = a.get_constants()\n d = np.array([[D1,A1,F1,1.0,0.0,0.0,F1,1.0],[D2,A2,F2,0.0,S12,0.0,F2,1.0]])\n for i in range(0, 2) :\n for j in range(0, 8) :\n self.input_materials +='%12.4e' %(d[i,j])\n self.input_materials += '\\n'\n self.input_materials += \"WHITE\\n\" + \"BLACK\\n\" + \"END\\n\"","def create_weight_matrices(self):\n rad = 1 / np.sqrt(self.no_of_in_nodes)\n X = truncated_normal(mean=0, \n sd=1, \n low=-rad, \n upp=rad)\n self.wih = X.rvs((self.no_of_hidden_nodes, \n self.no_of_in_nodes))\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\n self.who = X.rvs((self.no_of_out_nodes, \n self.no_of_hidden_nodes))","def _calc_matrix(self):\n\t\tz = self.zoom\n\t\talloc = self.allocation\n\t\tif self.image:\n\t\t\tiw, ih = self.image.get_width(), self.image.get_height()\n\t\telse:\n\t\t\tiw, ih = 0, 0\n#\t\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\n\t\t\n\t\ti2w = cairo.Matrix(\n\t\t\tz,0,\n\t\t\t0,z,\n\t\t\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \n\t\t\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\n\t\t\t)\n\t\t\n\t\tself._i2w_matrix = i2w\n\t\t\n\t\tw2i = cairo.Matrix(*i2w) #copy\n\t\tw2i.invert()\n\t\tself._w2i_matrix = w2i","def _build_model(self):\n\n with tf.variable_scope(\"Matchnet\", reuse=tf.AUTO_REUSE):\n # For determining the runtime shape\n x_shp = tf.shape(self.x_in)\n\n # -------------------- Network archintecture --------------------\n # Build graph\n print(\"Building Graph\")\n self.logits = build_graph(self.x_in, self.is_training, self.config)\n # ---------------------------------------------------------------\n\n # Turn into weights for each sample\n weights = tf.nn.relu(tf.tanh(self.logits))\n\n # Make input data (num_img_pair x num_corr x 4)\n xx = tf.transpose(tf.reshape(\n self.x_in, (x_shp[0], x_shp[2], 4)), (0, 2, 1))\n\n # Create the matrix to be used for the eight-point algorithm\n X = tf.transpose(tf.stack([\n xx[:, 2] * xx[:, 0], xx[:, 2] * xx[:, 1], xx[:, 2],\n xx[:, 3] * xx[:, 0], xx[:, 3] * xx[:, 1], xx[:, 3],\n xx[:, 0], xx[:, 1], tf.ones_like(xx[:, 0])\n ], axis=1), (0, 2, 1))\n print(\"X shape = {}\".format(X.shape))\n wX = tf.reshape(weights, (x_shp[0], x_shp[2], 1)) * X\n print(\"wX shape = {}\".format(wX.shape))\n XwX = tf.matmul(tf.transpose(X, (0, 2, 1)), wX)\n print(\"XwX shape = {}\".format(XwX.shape))\n\n # Recover essential matrix from self-adjoing eigen\n e, v = tf.self_adjoint_eig(XwX)\n self.e_hat = tf.reshape(v[:, :, 0], (x_shp[0], 9))\n # Make unit norm just in case\n self.e_hat /= tf.norm(self.e_hat, axis=1, keep_dims=True)","def build_augmented_matrix(self):\r\n for row in range(self.SIZE):\r\n self.matrix[row].append(self.result[row])","def generate(self):\n self.training_data.gen_x(self.x_func)\n self.training_data.gen_a(self.a_func)\n self.training_data.gen_y(self.y_func)\n \n self.testing_data.gen_x(self.x_func)\n self.testing_data.gen_ys(self.y_func)\n self.testing_data.gen_azero(self.ytotal_func)","def build_modules(self):\n self.backbone = Backbone(\n self.configs['backbone'],\n freeze_backbone=self.configs['freeze_backbone'],\n freeze_batchnorm=True\n )\n\n backbone_channel_sizes = get_backbone_channel_sizes(self.backbone)\n\n self.fpn = FeaturePyramidNetwork(\n backbone_channel_sizes=backbone_channel_sizes,\n min_feature_level=self.configs['min_feature_level'],\n max_feature_level=self.configs['max_feature_level'],\n feature_size=self.configs['pyramid_feature_size']\n )\n\n self.shared_conv_model = SharedConvModel(\n input_feature_size=self.configs['pyramid_feature_size'],\n feature_size=self.configs['shared_conv_feature_size'],\n num_layers=self.configs['shared_conv_num_layers']\n )\n\n if self.configs['shared_conv_num_layers'] > 0:\n shared_conv_output_size = self.configs['shared_conv_feature_size']\n else:\n shared_conv_output_size = self.configs['pyramid_feature_size']\n\n self.ofn = ObjectFinderNetwork(\n input_feature_size=shared_conv_output_size,\n feature_size=self.configs['finder_feature_size'],\n num_layers=self.configs['finder_num_layers']\n )\n\n self.ofn_loss_fn\n\n # self.classification_model = ClassificationModel()\n #\n # self.regression_model = RegressionModel()","def build(node):\n yield Matrix(node[Matrix.TAG])","def createMatrices(file, word2Idx, maxSentenceLen, extendMapping, labelsMapping, aspectMapping, typeMapping, tenseMapping, eventClassMapping, distanceMapping, sentenceLengthMapping):\n labels = []\n eventMatrix = []\n timeMatrix = []\n\n sentenceLengths = []\n sentenceMatrix = []\n positionMatrix_e = []\n positionMatrix_t = []\n\n aspectMatrix = []\n typeMatrix = []\n tenseMatrix = []\n eventClassMatrix = []\n featuresList = []\n \n \n minDistance = 0\n for distanceKey in distanceMapping.iterkeys():\n if isinstance(distanceKey, (int, long)):\n minDistance = min(minDistance, int(distanceKey))\n \n for line in open(file):\n features = eval(line.strip())\n featuresList.append(features)\n label = features['label']\n event = features[\"Token[0]\"]\n eventPosition = int(features[\"eventPosition\"])\n tokens = features[\"textInBetween\"] if \"textInBetween\" in features else features[\"sentence\"]\n \n aspect = features[\"aspect\"]\n tense = features[\"tense\"]\n eventClass = features[\"eventClass\"]\n \n labels.append(labelsMapping[label.lower()] if label.lower() in labelsMapping else -1)\n eventMatrix.append(getWordIdx(event, word2Idx))\n \n aspectMatrix.append(getMappingIdx(aspect, aspectMapping, extendMapping))\n tenseMatrix.append(getMappingIdx(tense, tenseMapping, extendMapping))\n eventClassMatrix.append(getMappingIdx(eventClass, eventClassMapping, extendMapping))\n \n if 'TimeTokenFirst' in features:\n time = features['TimeTokenFirst']\n timeMatrix.append(getWordIdx(time, word2Idx))\n \n if 'type' in features:\n type = features[\"type\"]\n typeMatrix.append(getMappingIdx(type, typeMapping, extendMapping))\n \n timePosition = int(features[\"timeFirstPosition\"]) if 'timeFirstPosition' in features else 0\n \n\n if len(tokens) in sentenceLengthMapping:\n sentenceLengths.append(sentenceLengthMapping[len(tokens)])\n else:\n sentenceLengths.append(sentenceLengthMapping['GreaterMax'])\n\n \n tokenIds = np.zeros(maxSentenceLen)\n positionValues_e = np.zeros(maxSentenceLen)\n positionValues_t = np.zeros(maxSentenceLen)\n for idx in xrange(0, min(maxSentenceLen, len(tokens))):\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\n \n distance_e = idx - eventPosition\n distance_t = idx - timePosition\n\n if distance_e in distanceMapping:\n positionValues_e[idx] = distanceMapping[distance_e]\n elif distance_e <= minDistance:\n positionValues_e[idx] = distanceMapping['LowerMin']\n else:\n positionValues_e[idx] = distanceMapping['GreaterMax']\n \n if distance_t in distanceMapping:\n positionValues_t[idx] = distanceMapping[distance_t]\n elif distance_t <= minDistance:\n positionValues_t[idx] = distanceMapping['LowerMin']\n else:\n positionValues_t[idx] = distanceMapping['GreaterMax']\n\n sentenceMatrix.append(tokenIds)\n positionMatrix_e.append(positionValues_e)\n positionMatrix_t.append(positionValues_t)\n\n \n labels = np.array(labels, dtype='int32')\n eventMatrix = np.expand_dims(np.array(eventMatrix, dtype='int32'), axis=1)\n timeMatrix = np.expand_dims(np.array(timeMatrix, dtype='int32'), axis=1)\n aspectMatrix = np.expand_dims(np.array(aspectMatrix, dtype='int32'), axis=1)\n typeMatrix = np.expand_dims(np.array(typeMatrix, dtype='int32'), axis=1)\n tenseMatrix = np.expand_dims(np.array(tenseMatrix, dtype='int32'), axis=1)\n eventClassMatrix = np.expand_dims(np.array(eventClassMatrix, dtype='int32'), axis=1)\n sentenceLengths = np.expand_dims(np.array(sentenceLengths, dtype='int32'), axis=1)\n \n \n sentenceMatrix = np.array(sentenceMatrix, dtype='int32')\n positionMatrix_e = np.array(positionMatrix_e, dtype='int32')\n positionMatrix_t = np.array(positionMatrix_t, dtype='int32')\n \n\n\n return {'labels': labels,\n 'event':eventMatrix, \n 'time':timeMatrix, \n 'sentence':sentenceMatrix, \n 'positions_e':positionMatrix_e, \n 'positions_t':positionMatrix_t, \n 'aspect':aspectMatrix, \n 'tense':tenseMatrix, \n 'eventClass':eventClassMatrix, \n 'type': typeMatrix,\n 'sentence_len': sentenceLengths,\n 'features': featuresList}","def run(self):\n # load_data\n layers = self.load_all_data() # list of tuples (file_name, feature_matrix)\n\n # check variable types\n if len(self.method) == 1:\n self.method = [self.method[0]] * len(layers)\n elif len(layers) != len(self.method):\n raise ValueError(\"Number of matrices extracted from input files and number of similarity methods \" +\n \"does not correspond\")\n\n # check missing value parameter\n if len(self.missing) == 1:\n self.logger.info(\"#Setting all 'missing' parameters to {}\".format(self.missing[0]))\n self.missing = [self.missing[0]] * len(layers)\n elif len(layers) != len(self.missing):\n raise ValueError(\"Number of matrices extracted from input files and number of given missing parameters \" +\n \"does not correspond\")\n\n # extract sample names\n all_samples = set()\n for layer_data in layers:\n all_samples = all_samples.union({name for name in layer_data[1].columns})\n self.logger.info(\"#Total number of unique samples: {}\".format(len(all_samples)))\n\n out_arrays = {}\n adj_matrices = []\n\n # create adjacency matrices\n for i in range(len(layers)):\n self.logger.info(\"#Layer: {}\".format(i))\n layer_data = layers[i][1]\n\n # add missing samples layer\n samples = {name for name in layer_data.columns}\n for name in all_samples - samples:\n layer_data[name] = np.nan\n\n # sort data frame by sample names\n layer_data.sort_index(axis=1, inplace=True)\n\n # extract feature matrices\n f = layer_data.values.T\n self.logger.info(\"Feature matrix: ({} samples x {} features)\".format(f.shape[0], f.shape[1]))\n\n # check if feature matrix values are correct\n ncat = check_categories(f)\n if ncat != [0, 1]:\n standardized = is_standardized(f, axis=0, atol=self.atol)\n if not standardized[0]:\n raise ValueError(\"Incorrect values in feature matrix. Mean of features in \" +\n \"({},{}) \".format(round(standardized[1][0], 3), round(standardized[1][1], 3)) +\n \"range. Standard deviation of features in \" +\n \"({}, {}) \".format(round(standardized[2][0], 3), round(standardized[2][1], 3)) +\n \"range. Please, supply either binary dataset \" +\n \"(0 or 1 feature values) or continuous values standardized feature-wise. \" +\n \"Alternatively for almost standardized continuous data, \" +\n \"increase '-atol' parameter value (currently {}).\".format(self.atol))\n else:\n self.logger.debug(\"Data is correctly standardized\")\n else:\n self.logger.debug(\"Found two unique categories in data: [0, 1]\")\n if self.method[i] != 'cosine':\n self.logger.info(\"Using '{}' similarity for [0, 1] data. \".format(self.method[i]) +\n \"Suggested better measure: cosine similarity.\")\n\n # create adjacency matrix\n a = feature_to_adjacency(f, missing=self.missing[i], method=self.method[i], n=self.k, alpha=self.alpha)\n self.logger.info('Adjacency matrix {} created [similarity method: {}]'.format(a.shape, self.method[i]))\n\n # plot adjacency matrix\n plot_path = self.plot_base + \"_\" + str(i) + \".png\" if self.plot else self.plot_base\n plot_heatmap_seaborn(a, title=\"Layer {} (source:{})\".format(i, layers[i][0]), file_path=plot_path)\n if self.plot:\n self.logger.info(\"Adjacency matrix plot saved to {}\".format(plot_path))\n\n # add matrices to output arrays\n out_arrays[str(i)] = a\n adj_matrices.append(a)\n out_arrays[\"f\" + str(i)] = f\n\n # check if there are samples not accessible in any layer\n missing_samples = []\n for a in adj_matrices:\n missing_samples += [i for i in range(a.shape[1]) if np.all(np.isnan(a[:, i]))]\n\n samples_to_drop = [sample for sample, val in Counter(missing_samples).items() if val == len(adj_matrices)]\n if samples_to_drop:\n # drop inaccessible samples\n self.logger.info(\"Found samples inaccessible in every layer of graph. \" +\n \"Try changing '-missing' parameter or inspect your data \")\n sample_names = np.array(sorted(list(all_samples)))[np.array(samples_to_drop)]\n self.logger.info(\"Dropped samples: {}\".format(list(sample_names)))\n updated_out_arrays = {}\n selector = np.array([x for x in range(len(all_samples)) if x not in samples_to_drop])\n for i in range(len(out_arrays.keys())):\n if str(i) not in out_arrays.keys():\n break\n updated_out_arrays[str(i)] = out_arrays[str(i)][selector[:, None], selector]\n updated_out_arrays[\"f\" + str(i)] = out_arrays[\"f\" + str(i)][selector, :]\n\n # create output file\n updated_out_arrays[\"samples\"] = np.array(sorted(list(all_samples)))[selector]\n save_arrays_to_npz(data=updated_out_arrays, file_path=self.outfile)\n\n else:\n # create output file\n out_arrays[\"samples\"] = np.array(sorted(list(all_samples)))\n save_arrays_to_npz(data=out_arrays, file_path=self.outfile)\n\n self.logger.info(\"#Output file {} created\".format(self.outfile))","def build_generator2D_(self, model_shape, filters=32, k_size=4, z_size=500, summary=False, model_file=None, name='gan_g_'):\n if (model_file):\n \"\"\"\n Load pretreined model\n \"\"\"\n model = self.utils.build_pretrained_model(model_file)\n if (summary):\n model.summary()\n return model\n else:\n\n n_rows = model_shape[0]\n n_cols = model_shape[1]\n c_dims = model_shape[2]\n input_shape = (z_size,)\n if n_rows % 8 !=0:\n height = n_rows//8 + 1\n else:\n height = n_rows//8\n if n_cols % 8 !=0:\n width = n_cols//8 +1\n else:\n width = n_cols//8\n \n num_init_neurons = 8*filters \n reshape_size= (height, width, num_init_neurons)\n \n # 8*height, 4*height, 2*height, height = n_rows, n_rows//2, n_rows//4, n_rows//8\n rows_matching = np.equal([2*height, 4*height, 8*height], [n_rows//4, n_rows//2, n_rows])\n index_rows = np.where(np.logical_not(rows_matching))[0]\n if len(index_rows) > 0:\n index_rows = index_rows[0]\n # print(index_rows)\n # 8*width, 4*width, 2*width, width = n_cols//1, n_cols//2, n_cols//4, n_cols//8\n cols_matching = np.equal([2*width, 4*width, 8*width], [n_cols//4, n_cols//2, n_cols])\n index_cols = np.where(np.logical_not(cols_matching))[0]\n if len (index_cols) > 0:\n index_cols = index_cols[0]\n # print(index_cols)\n\n input_layer = Input(shape=input_shape, name=name+'input')\n g = Dense(width * height * num_init_neurons, kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(input_layer)\n g = Reshape(reshape_size, name=name+'reshape')(g)\n g = BatchNormalization(momentum=0.8, name=name+'bn_dense')(g, training=True)\n g = Activation(activation='relu', name=name+'relu')(g)\n\n g = self.Conv2DTranspose_Block(g, 4*filters, name=name+'1')\n if index_rows==0 or index_cols==0:\n g = BilinearUpsampling(output_size=(n_rows//4, n_cols//4), name=name+'bilinear')(g)\n g = self.Conv2DTranspose_Block(g, 2*filters, k_size=k_size, name=name+'2')\n if index_rows==1 or index_cols==1:\n g = BilinearUpsampling(output_size=(n_rows//2, n_cols//2), name=name+'bilinear')(g)\n g = self.Conv2DTranspose_Block(g, 1*filters, k_size=k_size, name=name+'3')\n if index_rows==2 or index_cols==2:\n g = BilinearUpsampling(output_size=(n_rows, n_cols), name=name+'bilinear')(g) \n g = self.Conv2DTranspose_Block(g, c_dims, strides=1, activation='tanh', k_size=k_size, name=name+'4', bn=False)\n\n model = Model(inputs=[input_layer], outputs=[g], name='Generator')\n if (summary):\n model.summary()\n return model","def __init__(\n self,\n numpy_rng,\n train_set_x,\n train_set_y,\n hidden_layers_sizes,\n n_ins=784,\n n_outs=10\n ):\n\n self.sigmoid_layers = []\n self.AE_layers = []\n self.params = []\n self.n_layers = len(hidden_layers_sizes)\n self.train_set_x = train_set_x\n self.train_set_y = train_set_y\n\n assert self.n_layers > 0\n\n self.x = T.matrix('x') # the data is presented as rasterized images\n self.y = T.ivector('y') # the labels are presented as 1D vector of\n\n for i in xrange(self.n_layers): # used to be n layers\n\n # construct the sigmoid layer = encoder stack\n if i == 0:\n layer_input = self.x\n else:\n layer_input = self.sigmoid_layers[-1].output\n\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\n input=layer_input,\n n_in=(n_ins if i == 0 else\n hidden_layers_sizes[i-1]),\n n_out=hidden_layers_sizes[i],\n activation=T.nnet.sigmoid)\n\n # add the layer to our list of layers\n self.sigmoid_layers.append(sigmoid_layer)\n self.params.extend(sigmoid_layer.params)\n\n # init the DA_layer, takes weights from sigmoid layer\n AE_layer = AutoEncoder(\n numpy_rng=numpy_rng,\n input=layer_input,\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\n n_hidden=hidden_layers_sizes[i],\n W=sigmoid_layer.W,\n bhid=sigmoid_layer.b)\n\n self.AE_layers.append(AE_layer)\n\n # on top of the layers\n # log layer for fine-tuning\n self.logLayer = LogisticRegression(\n input=self.sigmoid_layers[-1].output,\n n_in=hidden_layers_sizes[-1],\n n_out=n_outs\n )\n self.params.extend(self.logLayer.params)\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\n self.errors = self.logLayer.errors(self.y)","def generate(self):\n t_0 = time()\n\n if self.random_towers:\n self.towers = np.random.rand(self.number_towers, 2)\n else:\n step = np.ceil(np.sqrt(self.number_towers)).astype('int')\n\n if step ** 2 != self.number_towers:\n self.number_towers = step ** 2\n print(f'WARNING: number of towers changed to {self.number_towers}')\n\n X, Y = np.mgrid[0:1:step * 1j, 0:1:step * 1j]\n positions = np.vstack([X.ravel(), Y.ravel()])\n self.towers = positions.swapaxes(1, 0)\n\n self.towers_manager = TowersManager(self.towers, self.vel_friction)\n\n self.distances = self.towers_manager.generate_distances()\n self.print(f'Took {time() - t_0} to create distrances matrix')\n\n t = time()\n self.probabilities = self.generate_probabilities()\n self.print(f'Took {time() - t} to create probabilities matrix')\n\n t = time()\n self.traces = self.generate_weighted_users_traces()\n self.print(f'Took {time() - t} to create user traces')\n\n t = time()\n self.aggregated_data = self.generate_aggregate_data()\n self.print(f'Took {time() - t} to build aggregated data')\n\n self.print(f'Took {time() - t_0} to generate all')","def create_matrix(self):\n\n self.matrix = np.zeros((len(self.users), len(self.items)))\n\n for user in self.train_set['users']:\n for item in self.train_set['feedback'][user]:\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\n self.train_set['feedback'][user][item]","def convert(self):\n self.tilewidth = int(self.tilewidth)\n self.tileheight = int(self.tileheight)\n self.width = int(self.width)\n self.height = int(self.height)\n self.pixel_width = self.width * self.tilewidth\n self.pixel_height = self.height * self.tileheight\n for layer in self.layers:\n self.named_layers[layer.name] = layer\n layer.opacity = float(layer.opacity)\n layer.x = int(layer.x)\n layer.y = int(layer.y)\n layer.width = int(layer.width)\n layer.height = int(layer.height)\n layer.pixel_width = layer.width * self.tilewidth\n layer.pixel_height = layer.height * self.tileheight\n layer.visible = bool(int(layer.visible))\n for tile_set in self.tile_sets:\n self.named_tile_sets[tile_set.name] = tile_set\n tile_set.spacing = int(tile_set.spacing)\n tile_set.margin = int(tile_set.margin)\n for img in tile_set.images:\n if img.trans:\n img.trans = (int(img.trans[:2], 16), int(img.trans[2:4], 16), int(img.trans[4:], 16))\n for obj_group in self.object_groups:\n obj_group.x = int(obj_group.x)\n obj_group.y = int(obj_group.y)\n obj_group.width = int(obj_group.width)\n obj_group.height = int(obj_group.height)\n for map_obj in obj_group.objects:\n map_obj.x = int(map_obj.x)\n map_obj.y = int(map_obj.y)\n map_obj.width = int(map_obj.width)\n map_obj.height = int(map_obj.height)","def convert(self):\n self.tilewidth = int(self.tilewidth)\n self.tileheight = int(self.tileheight)\n self.width = int(self.width)\n self.height = int(self.height)\n self.pixel_width = self.width * self.tilewidth\n self.pixel_height = self.height * self.tileheight\n for layer in self.layers:\n self.named_layers[layer.name] = layer\n layer.opacity = float(layer.opacity)\n layer.x = int(layer.x)\n layer.y = int(layer.y)\n layer.width = int(layer.width)\n layer.height = int(layer.height)\n layer.pixel_width = layer.width * self.tilewidth\n layer.pixel_height = layer.height * self.tileheight\n layer.visible = bool(int(layer.visible))\n for tile_set in self.tile_sets:\n self.named_tile_sets[tile_set.name] = tile_set\n tile_set.spacing = int(tile_set.spacing)\n tile_set.margin = int(tile_set.margin)\n for img in tile_set.images:\n if img.trans:\n img.trans = (int(img.trans[:2], 16), int(img.trans[2:4], 16), int(img.trans[4:], 16))\n for obj_group in self.object_groups:\n obj_group.x = int(obj_group.x)\n obj_group.y = int(obj_group.y)\n obj_group.width = int(obj_group.width)\n obj_group.height = int(obj_group.height)\n for map_obj in obj_group.objects:\n map_obj.x = int(map_obj.x)\n map_obj.y = int(map_obj.y)\n map_obj.width = int(map_obj.width)\n map_obj.height = int(map_obj.height)","def build_generator2D(self, model_shape, filters=32, k_size=4, z_size=500, summary=False, model_file=None, name='gan_g_'):\n if (model_file):\n \"\"\"\n Load pretreined model\n \"\"\"\n model = self.utils.build_pretrained_model(model_file)\n if (summary):\n model.summary()\n return model\n else:\n\n n_rows = model_shape[0]\n n_cols = model_shape[1]\n input_shape = (z_size,)\n if n_rows % 8 !=0:\n height = n_rows//8 + 1\n else:\n height = n_rows//8\n if n_cols % 8 !=0:\n width = n_cols//8 +1\n else:\n width = n_cols//8\n \n num_init_neurons = 8*filters \n reshape_size= (height, width, num_init_neurons)\n \n # 8*height, 4*height, 2*height, height = n_rows, n_rows//2, n_rows//4, n_rows//8\n rows_matching = np.equal([2*height, 4*height, 8*height], [n_rows//4, n_rows//2, n_rows])\n index_rows = np.where(np.logical_not(rows_matching))[0]\n if len(index_rows) > 0:\n index_rows = index_rows[0]\n # print(index_rows)\n # 8*width, 4*width, 2*width, width = n_cols//1, n_cols//2, n_cols//4, n_cols//8\n cols_matching = np.equal([2*width, 4*width, 8*width], [n_cols//4, n_cols//2, n_cols])\n index_cols = np.where(np.logical_not(cols_matching))[0]\n if len (index_cols) > 0:\n index_cols = index_cols[0]\n # print(index_cols)\n\n input_layer = Input(shape=input_shape, name=name+'input')\n g = Dense(width * height * num_init_neurons, kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(input_layer)\n g = Reshape(reshape_size, name=name+'reshape')(g)\n g = BatchNormalization(momentum=0.8, name=name+'bn_dense')(g, training=True)\n g = Activation(activation='relu', name=name+'relu')(g)\n\n g = self.Conv2DTranspose_Block(g, 4*filters, name=name+'1')\n if index_rows==0 or index_cols==0:\n g = BilinearUpsampling(output_size=(n_rows//4, n_cols//4), name=name+'bilinear')(g)\n g = self.Conv2DTranspose_Block(g, 2*filters, k_size=k_size, name=name+'2')\n if index_rows==1 or index_cols==1:\n g = BilinearUpsampling(output_size=(n_rows//2, n_cols//2), name=name+'bilinear')(g)\n g = self.Conv2DTranspose_Block(g, 1*filters, k_size=k_size, name=name+'3')\n if index_rows==2 or index_cols==2:\n g = BilinearUpsampling(output_size=(n_rows, n_cols), name=name+'bilinear')(g) \n g = self.Conv2DTranspose_Block(g, 2, strides=1, activation='tanh', k_size=k_size, name=name+'4', bn=False)\n\n model = Model(inputs=[input_layer], outputs=[g], name='Generator')\n if (summary):\n model.summary()\n return model","def MeshMachine(main):\n\n # oDesign definition\n oDesign = main['ANSYS']['oDesign']\n\n # Data for the rotor mesh\n RotorName = main['ANSYS']['Rotor&Magnets']['Name'][0]\n RotorNumMaxElem = main['ANSYS']['Mesh']['Rotor']['NumMaxElem']\n RotorMaxLength = main['ANSYS']['Mesh']['Rotor']['MaxLength']\n\n # Data for the magnets mesh\n PMNames = main['ANSYS']['Rotor&Magnets']['PMNames']\n PMNumMaxElem = main['ANSYS']['Mesh']['Magnets']['NumMaxElem']\n PMMaxLength = main['ANSYS']['Mesh']['Magnets']['MaxLength']\n\n # Data for the Stator mesh\n StatorName = main['ANSYS']['Stator']['Name']\n StatorNormalDev = main['ANSYS']['Mesh']['Stator']['NormalDev']\n StatorAspectRatio = main['ANSYS']['Mesh']['Stator']['AspectRatio']\n\n # Data for the Stator mesh\n CoilNames = main['ANSYS']['Winding']['CoilNames']\n WindingNumMaxElem = main['ANSYS']['Mesh']['Winding']['NumMaxElem']\n WindingMaxLength = main['ANSYS']['Mesh']['Winding']['MaxLength']\n\n WindingName = []\n for phase in CoilNames:\n for direction in phase:\n WindingName += direction\n\n # Creating meshes\n oModule = oDesign.GetModule(\"MeshSetup\")\n\n # Rotor meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Rotor\",\n \"RefineInside:=\", True,\n \"Enabled:=\", True,\n \"Objects:=\", [RotorName],\n \"RestrictElem:=\", False,\n \"NumMaxElem:=\", str(RotorNumMaxElem),\n \"RestrictLength:=\", True,\n \"MaxLength:=\", str(RotorMaxLength)+\"mm\"\n ]\n )\n # Magnet meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Magnets\",\n \"RefineInside:=\", True,\n \"Enabled:=\", True,\n \"Objects:=\", PMNames,\n \"RestrictElem:=\", False,\n \"NumMaxElem:=\", str(PMNumMaxElem),\n \"RestrictLength:=\", True,\n \"MaxLength:=\", str(PMMaxLength)+\"mm\"\n ]\n )\n # Stator meshes\n oModule.AssignTrueSurfOp(\n [\n \"NAME:Stator\",\n \"Objects:=\", [StatorName],\n \"CurvedSurfaceApproxChoice:=\", \"ManualSettings\",\n \"SurfDevChoice:=\", 0,\n \"NormalDevChoice:=\", 2,\n \"NormalDev:=\", str(StatorNormalDev) + \"deg\",\n \"AspectRatioChoice:=\", 2,\n \"AspectRatio:=\", str(StatorAspectRatio)\n ]\n )\n\n # Coil meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Coils\",\n \"RefineInside:=\"\t, True,\n \"Enabled:=\"\t\t, True,\n \"Objects:=\"\t\t, WindingName,\n \"RestrictElem:=\"\t, False,\n \"NumMaxElem:=\"\t\t, str(WindingNumMaxElem),\n \"RestrictLength:=\"\t, True,\n \"MaxLength:=\"\t\t, str(WindingMaxLength) +\"mm\"\n ]\n )\n\n return main","def build_mat(self):\n for row, s in enumerate(self.S):\n for col, t in enumerate(self.T):\n\n if self.symmetric and row > col:\n pass\n\n else:\n self.mat[row, col] = self.kernel(s, t, self.n)\n\n if self.symmetric:\n self.mat = self.symmetrize(self.mat)\n else:\n for idx, s in enumerate(self.S):\n self.test_normalization[idx] = self.kernel(s, s, self.n)","def build(classes):\n # data input\n data = mx.sym.Variable(\"data\")\n\n # Block #1: first CONV => RELU => POOL layer set\n conv1_1 = mx.sym.Convolution(data=data, kernel=(11, 11), stride=(4, 4), num_filter=96)\n act1_1 = mx.sym.LeakyReLU(data=conv1_1, act_type=\"elu\")\n bn1_1 = mx.sym.BatchNorm(data=act1_1)\n pool1 = mx.sym.Pooling(data=bn1_1, pool_type=\"max\", kernel=(3, 3), stride=(2, 2))\n do1 = mx.sym.Dropout(data=pool1, p=0.25)\n\n # Block #2: second CONV => RELU => POOL layer set\n conv2_1 = mx.sym.Convolution(data=do1, kernel=(5, 5), pad=(2, 2), num_filter=256)\n act2_1 = mx.sym.LeakyReLU(data=conv2_1, act_type=\"elu\")\n bn2_1 = mx.sym.BatchNorm(data=act2_1)\n pool2 = mx.sym.Pooling(data=bn2_1, pool_type=\"max\", kernel=(3, 3), stride=(2, 2))\n do2 = mx.sym.Dropout(data=pool2, p=0.25)\n\n # Block #3: (CONV => RELU) * 3 => POOL\n conv3_1 = mx.sym.Convolution(data=do2, kernel=(3, 3), pad=(1, 1), num_filter=384)\n act3_1 = mx.sym.LeakyReLU(data=conv3_1, act_type=\"elu\")\n bn3_1 = mx.sym.BatchNorm(data=act3_1)\n conv3_2 = mx.sym.Convolution(data=bn3_1, kernel=(3, 3), pad=(1, 1), num_filter=384)\n act3_2 = mx.sym.LeakyReLU(data=conv3_2, act_type=\"elu\")\n bn3_2 = mx.sym.BatchNorm(data=act3_2)\n conv3_3 = mx.sym.Convolution(data=bn3_2, kernel=(3, 3), pad=(1, 1), num_filter=256)\n act3_3 = mx.sym.LeakyReLU(data=conv3_3, act_type=\"elu\")\n bn3_3 = mx.sym.BatchNorm(data=act3_3)\n pool3 = mx.sym.Pooling(data=bn3_3, pool_type=\"max\", kernel=(3, 3), stride=(2, 2))\n do3 = mx.sym.Dropout(data=pool3, p=0.25)\n\n # Block #4: first set of FC => RELU layers\n flatten = mx.sym.Flatten(data=do3)\n fc1 = mx.sym.FullyConnected(data=flatten, num_hidden=4096)\n act4_1 = mx.sym.LeakyReLU(data=fc1, act_type=\"elu\")\n bn4_1 = mx.sym.BatchNorm(data=act4_1)\n do4 = mx.sym.Dropout(data=bn4_1, p=0.5)\n\n # Block #5: second set of FC => RELU layers\n fc2 = mx.sym.FullyConnected(data=do4, num_hidden=4096)\n act5_1 = mx.sym.LeakyReLU(data=fc2, act_type=\"elu\")\n bn5_1 = mx.sym.BatchNorm(data=act5_1)\n do5 = mx.sym.Dropout(data=bn5_1, p=0.5)\n\n # softmax classifier\n fc3 = mx.sym.FullyConnected(data=do5, num_hidden=classes)\n model = mx.sym.SoftmaxOutput(data=fc3, name=\"softmax\")\n\n # return the network architecture\n return model","def generate_tiles(self):\n if self.children:\n for child in self.children:\n child.generate_tiles()\n print \"Generating tile for %s using child tiles\" % self.bbox\n self.generate_tile_from_child_tiles()\n else:\n print \"Generating tile for %s using source data\" % self.bbox\n self.generate_tile_from_source()","def drawMatrix(self,screen,pos):\n bp = pos # base position bp\n namesurface = myfont.render(self.parentname, False, self.parentcolour)\n screen.blit(namesurface,(bp[0]-50,bp[1] -60),) \n tempOffset = namesurface.get_width()\n namesurface = myfont.render(self.name, False, self.colour)\n screen.blit(namesurface,(bp[0]-40 ,bp[1]-30),) \n size = 10\n separationx = 12\n separationy = 20\n # Cycle through array of inputs\n for i in range(self.dimensions[0]):\n # Create red - green colour based on array\n temp_colour = (int((1-self.scan[i])*240),int(self.scan[i]*240),0)\n # Draw square that is slightly offset of previous square\n pygame.draw.rect(screen,temp_colour ,(bp[0] - separationx *int(i / len(self.inputdistance)),\n bp[1] - separationx*(i%len(self.inputdistance)) + 3*separationx,size,size))\n # Calculate intermediate decision array\n temp_vector = self.scan \n # Repeat\n for j, bs in enumerate(self.bias):\n temp_vector = np.add(temp_vector.dot(self.weights[j]), bs)\n for i in range(temp_vector.shape[0]):\n temp_colour = (int(max(min((1-temp_vector[i])*240,240),0)),int(max(min(temp_vector[i]*240,240),0)),0)\n pygame.draw.rect(screen,temp_colour ,(bp[0] + (j+1)*separationy,bp[1] + separationx*i,size,size))","def _make_random_matrix(self, n_components, n_features):","def _build_matrix(self, image):\n offset_generator = self._iter_images_rects()\n count = 1\n for src_image in self._iter_images():\n pos_x, pos_y, max_w, max_h = next(offset_generator)\n src_image, width, height = self._image_resize_keep_ratio(src_image, max_w, max_h, self._crop)\n # Adjust position to have identical margin between borders and images\n if len(self._images) < 4:\n pos_x, pos_y = pos_x + (max_w - width) // 2, pos_y + (max_h - height) // 2\n elif count == 1:\n pos_x, pos_y = pos_x + (max_w - width) * 2 // 3, pos_y + (max_h - height) * 2 // 3\n elif count == 2:\n pos_x, pos_y = pos_x + (max_w - width) // 3, pos_y + (max_h - height) * 2 // 3\n elif count == 3:\n pos_x, pos_y = pos_x + (max_w - width) * 2 // 3, pos_y + (max_h - height) // 3\n else:\n pos_x, pos_y = pos_x + (max_w - width) // 3, pos_y + (max_h - height) // 3\n\n self._image_paste(src_image, image, pos_x, pos_y)\n count += 1\n return image","def compile(self):\n self.train = self._make_train()\n self.loss_test = self._make_loss_test()\n self.predict = self._make_predict()","def setUp(self):\r\n self.matrix = array(\r\n [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])\r\n self.cells = [(0, 1), (1, 3)]\r\n self.cells2 = [(0, 2), (2, 3)]","def generate():","def generate(self):","def gen_matrix(e):\n\tif e < 1:\n\t\treturn None\n\tm_list = [[[1, 2], [3, 0]]]\n\t_b = m_list[0]\n\tfor n in xrange(1, e):\n\t\tm = m_list[n - 1]\n\t\tm_list.append(\n\t\t\t[\n\t\t\t\t[4 * i + _b[0][0] for i in m[0]] + [4 * i + _b[0][1] for i in m[0]],\n\t\t\t\t[4 * i + _b[0][0] for i in m[1]] + [4 * i + _b[0][1] for i in m[1]],\n\t\t\t\t[4 * i + _b[1][0] for i in m[0]] + [4 * i + _b[1][1] for i in m[0]],\n\t\t\t\t[4 * i + _b[1][0] for i in m[1]] + [4 * i + _b[1][1] for i in m[1]],\n\t\t\t]\n\t\t)\n\treturn m_list","def _initializeMatrices(self):\n K = self.K \n # Initialize Initia\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\n rand_initial_prob = list(rand_initial_prob[0,:])\n for i in range(K): \n self.state_initial_prob[i+1] = rand_initial_prob[i]\n\n # Initialize the transition MAtrix !\n for i in range(K):\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\n rand_initial_prob = list(rand_initial_prob[0,:]) \n\n for j in range(K):\n self.state_transition_mat[(j+1,i+1)] = rand_initial_prob[j]\n\n\n # Initialize the symbol distribution Parameters ui and si (Assuming a numeric outputs ! Modelled using a gaussian ! withmean ui and std si)\n init_mean = np.mean(self.data_matrix)\n init_std = np.std(self.data_matrix) \n \n for i in range(K):\n random_mean = gauss(init_mean,30)\n random_std = gauss(init_std,30)\n self.state_symbol_prob[i+1] = {'mean':random_mean, 'std' : random_std}","def create_output_matrix_files(self, year, max_zone_id):\r\n from opus_emme2.travel_model_output import TravelModelOutput\r\n tm_output = TravelModelOutput(self.emme_cmd)\r\n year_config = self.config['travel_model_configuration'][year]\r\n for x in 1,2,3:\r\n if \"bank%i\" % x in year_config['matrix_variable_map']:\r\n bank_dir = self.get_emme2_dir(year, \"bank%i\" % x)\r\n for matrix_name in year_config['matrix_variable_map'][\"bank%i\" % x].keys():\r\n tm_output._get_matrix_into_data_file(matrix_name, max_zone_id, bank_dir, \"%s_one_matrix.txt\" % matrix_name)","def build_layers(self):\n raise NotImplementedError","def make_input_map(self) :\n\n self.input_map = \"\"\n stencil = self.core.stencil\n pattern = self.core.pattern\n reflect = len(pattern)+1 # reflector id, last material\n N = self.dimension\n coremap = np.zeros((N+2,N+2), dtype='i')\n \n # reflections and vacuum\n coremap[0, 1:N+1] = -1 \n coremap[1:N+1, 0] = -1\n coremap[N+1, 1:N+1] = -2\n coremap[1:N+1, N+1] = -2\n \n fuelindex = 0\n \n for i in range(1, N+1) :\n for j in range(1, N+1) :\n if j == 1 and i > 1 :\n pass\n else :\n if stencil[i-1, j-1] > 0 : # a fuel\n coremap[i, j] = pattern[fuelindex]+1\n fuelindex += 1\n elif stencil[i-1, j-1] == 0 : # a reflector\n coremap[i, j] = reflect\n else : # a void\n pass \n # Copy elements such that rotational symmetry is enforced. \n for j in range(2, N+1) :\n coremap[j, 1] = coremap[1, j]\n for i in range(0, N+2) :\n for j in range(0, N+2) :\n self.input_map +='%4i' % (coremap[i, j])\n self.input_map += '\\n'","def _init_model(self):\n self.A_inv = np.zeros(shape=(self.numUsers, self.d, self.d))\n self.b = np.zeros(shape=(self.numUsers, self.d))\n self.w = np.zeros(shape=(self.numUsers, self.d))\n for i, mat in enumerate(self.A_inv):\n self.A_inv[i] = np.eye(self.d)","def build(self):\n\n self.W_AA = self.init([self.n_atom_input_feat, self.n_hidden_AA])\n self.b_AA = model_ops.zeros(shape=[\n self.n_hidden_AA,\n ])\n\n self.W_PA = self.init([self.n_pair_input_feat, self.n_hidden_PA])\n self.b_PA = model_ops.zeros(shape=[\n self.n_hidden_PA,\n ])\n\n self.W_A = self.init([self.n_hidden_A, self.n_atom_output_feat])\n self.b_A = model_ops.zeros(shape=[\n self.n_atom_output_feat,\n ])\n\n self.trainable_weights = [\n self.W_AA, self.b_AA, self.W_PA, self.b_PA, self.W_A, self.b_A\n ]\n if self.update_pair:\n self.W_AP = self.init([self.n_atom_input_feat * 2, self.n_hidden_AP])\n self.b_AP = model_ops.zeros(shape=[\n self.n_hidden_AP,\n ])\n\n self.W_PP = self.init([self.n_pair_input_feat, self.n_hidden_PP])\n self.b_PP = model_ops.zeros(shape=[\n self.n_hidden_PP,\n ])\n\n self.W_P = self.init([self.n_hidden_P, self.n_pair_output_feat])\n self.b_P = model_ops.zeros(shape=[\n self.n_pair_output_feat,\n ])\n\n self.trainable_weights.extend(\n [self.W_AP, self.b_AP, self.W_PP, self.b_PP, self.W_P, self.b_P])","def _build(self):\n with tf.variable_scope (self.name + '_architecutre') as scope:\n images_square = unflatten_layer ( self.images )\n visualize_images(images_square)\n\n # Conv Layer 1\n conv1_out, params = conv_2d_layer ( input = images_square,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n name = 'enc_conv_1',\n visualize = True )\n process_params(params, name = self.name)\n e1_params = params\n pool1_out = max_pool_2d_layer ( input = conv1_out, name = 'enc_pool_1')\n # lrn1_out = local_response_normalization_layer (pool1_out, name = 'lrn_1' )\n\n # Conv Layer 2\n conv2_out, params = conv_2d_layer ( input = pool1_out,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n name = 'enc_conv_2' )\n process_params(params, name = self.name)\n e2_params = params\n pool2_out = max_pool_2d_layer ( input = conv2_out, name = 'enc_pool_2')\n # lrn2_out = local_response_normalization_layer (pool2_out, name = 'lrn_2' )\n\n flattened = flatten_layer(pool2_out)\n\n # Dropout Layer 1 \n flattened_dropout = dropout_layer ( input = flattened,\n prob = self.dropout_prob,\n name = 'enc_dropout_1') \n\n # Dot Product Layer 1\n fc1_out, params = dot_product_layer ( input = flattened_dropout,\n neurons = HIDDEN_1,\n name = 'enc_dot_1')\n process_params(params, name = self.name)\n e3_params = params \n\n # Dropout Layer 2 \n fc1_out_dropout = dropout_layer ( input = fc1_out,\n prob = self.dropout_prob,\n name = 'enc_dropout_2')\n # Dot Product Layer 2\n fc2_out, params = dot_product_layer ( input = fc1_out_dropout, \n neurons = HIDDEN_2,\n name = 'enc_dot_2')\n process_params(params, name = self.name)\n e4_params = params \n\n # Dropout Layer 3 \n fc2_out_dropout = dropout_layer ( input = fc2_out,\n prob = self.dropout_prob,\n name = 'enc_dropout_3')\n \n # Dot Product Layer 2\n self.codeword, params = dot_product_layer ( input = fc2_out_dropout, \n neurons = CODEWORD_LENGTH,\n activation = CODE_ACTIVATION,\n name = 'enc_dot_2')\n process_params(params, name = self.name)\n process_codeword_normalization_regularizer(self.codeword, \n coeff = AUTOENCODER_CODEWORD_COEFF,\n name = self.name)\n e5_params = params \n # tf.summary.histogram('codewords', self.codeword)\n # self.hash = threshold_layer ( input = self.codeword,\n # name = 'hash')\n # process_hash_regularizer(self.codeword, coeff = AUTOENCODER_HASH_COEFF,\n # name = self.name)\n\n # Decoder ... \n decoder_1_out, params = dot_product_layer ( input = self.codeword, \n neurons = HIDDEN_2,\n params = [tf.transpose(e5_params[0]), None],\n name = 'decoder_dot_1')\n d1_params = params\n process_params([params[1]], name = self.name)\n \n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\n prob = self.dropout_prob,\n name = 'dec_dropout_1')\n\n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \n neurons = HIDDEN_1,\n params = [tf.transpose(e4_params[0]), None],\n name = 'decoder_dot_2')\n d2_params = params\n process_params([params[1]], name = self.name)\n \n # dropout 2\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\n prob = self.dropout_prob,\n name = 'dec_dropout_2')\n\n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \n neurons = 1250,\n params = [tf.transpose(e3_params[0]), None],\n name = 'decoder_dot_3')\n d3_params = params\n process_params([params[1]], name = self.name)\n\n # DeConv Layer 1\n # The output shapes need to be changed according to architecture.\n\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N )\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), name = 'dec_upsampling_1')\n\n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\n neurons = CONV_1_N,\n filter_size = CONV_2_FILT,\n output_shape = (12,12),\n # n_outs = MINI_BATCH_SIZE,\n stride = (1,1,1,1), \n params = [e2_params[0], None], \n name = 'dec_deconv_1' )\n\n process_params([params[1]], name = self.name)\n d4_params = params\n\n # DeConv Layer 2\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), name = 'dec_upsampling_2')\n decoded_images_square, params = deconv_2d_layer ( input = upsample_2,\n neurons = 1,\n filter_size = CONV_1_FILT,\n stride = (1,1,1,1),\n output_shape = (28,28),\n # n_outs = MINI_BATCH_SIZE, \n params = [e1_params[0], None], \n activation = 'tanh', \n name = 'dec_deconv_2' )\n \n process_params([params[1]], name = self.name)\n d5_params = params \n \n self.decoded = flatten_layer (decoded_images_square, in_shp = [-1, 28, 28, 1])\n visualize_images(decoded_images_square, name = 'decoded')\n # This is because transpose don't initialize.\n self.params = [ [e5_params[0], d1_params[1] ],\n [e4_params[0], d2_params[1] ],\n [e3_params[0], d3_params[1] ],\n [e2_params[0], d4_params[1] ],\n [e1_params[0], d5_params[1] ] ]\n\n with tf.variable_scope (self.name + '_objectives') as scope: \n with tf.variable_scope( self.name + '_decoder_error') as scope:\n reconstruction_error = rmse(self.images, self.decoded) \n tf.add_to_collection( self.name + '_objectives', reconstruction_error ) \n tf.summary.scalar('reconstruction_error', reconstruction_error)\n\n self._cook_optimizer( \n lr = AUTOENCODER_LR, \n optimizer = AUTOENCODER_OPTIMIZER,\n l1_coeff = AUTOENCODER_L1_COEFF,\n l2_coeff = AUTOENCODER_WEIGHT_DECAY_COEFF)","def _init_layers(self) -> None:\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\n self.cross_attn = MultiheadAttention(**self.cross_attn_cfg)\n self.embed_dims = self.self_attn.embed_dims\n self.ffn = FFN(**self.ffn_cfg)\n norms_list = [\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\n for _ in range(3)\n ]\n self.norms = ModuleList(norms_list)","def build(self):\n\n self.W = self.init([self.n_atom_input_feat, self.n_output])\n self.b = model_ops.zeros(shape=[\n self.n_output,\n ])\n\n self.trainable_weights = self.W + self.b","def generate_mos(laygen, objectname_pfix, placement_grid, routing_grid_m1m2, devname_mos_boundary, devname_mos_body,\n devname_mos_dmy, m=1, m_dmy=0, origin=np.array([0,0])):\n pg = placement_grid\n rg12 = routing_grid_m1m2\n pfix = objectname_pfix\n\n # placement\n imbl0 = laygen.relplace(name=\"I\" + pfix + 'BL0', templatename=devname_mos_boundary, gridname=pg, xy=origin)\n refi=imbl0\n if not m_dmy==0:\n imdmyl0 = laygen.relplace(name=\"I\" + pfix + 'DMYL0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\n refi=imdmyl0\n else:\n imdmyl0 = None\n im0 = laygen.relplace(name=\"I\" + pfix + '0', templatename=devname_mos_body, gridname=pg, refobj=refi, shape=[m, 1])\n refi=im0\n if not m_dmy==0:\n imdmyr0 = laygen.relplace(name=\"I\" + pfix + 'DMYR0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\n refi=imdmyr0\n else:\n imdmyr0 = None\n imbr0 = laygen.relplace(name=\"I\" + pfix + 'BR0', templatename=devname_mos_boundary, gridname=pg, refobj=imdmyr0)\n md=im0.elements[:, 0]\n #route\n #gate\n rg0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['G0'], refobj1=md[-1].pins['G0'])\n for _md in md:\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['G0'], gridname=rg12)\n #drain\n rdl0=laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=md[0].pins['D0'], refobj1=md[-1].pins['D0'])\n for _md in md:\n laygen.via(name=None, xy=[0, 1], refobj=_md.pins['D0'], gridname=rg12)\n #source\n rs0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['S0'], refobj1=md[-1].pins['S1'])\n for _md in md:\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['S0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=md[-1].pins['S1'], gridname=rg12)\n #dmy\n if m_dmy>=2:\n mdmyl=imdmyl0.elements[:, 0]\n mdmyr=imdmyr0.elements[:, 0]\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyl[0].pins['D0'], refobj1=mdmyl[-1].pins['D0'])\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyr[0].pins['D0'], refobj1=mdmyr[-1].pins['D0'])\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyl[0].pins['S0'], refobj1=mdmyl[-1].pins['S1'])\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyr[0].pins['S0'], refobj1=mdmyr[-1].pins['S1'])\n for _mdmyl in mdmyl:\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyl.pins['D0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyl.pins['S0'], gridname=rg12)\n for _mdmyr in mdmyr:\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyr.pins['D0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyr.pins['S1'], gridname=rg12)\n return [imbl0, imdmyl0, im0, imdmyr0, imbr0]","def initialize_matrices(self):\n assert self._training_dataset and self._valid_dataset\n # inject prior knowledge about transition and emission\n self._state_prior = torch.zeros(self._config.d_hidden, device=self._config.device) + 1e-2\n self._state_prior[0] += 1 - self._state_prior.sum()\n\n intg_obs = list(map(np.array, self._training_dataset.obs + self._valid_dataset.obs))\n self._trans_mat = torch.tensor(initialise_transmat(\n observations=intg_obs, label_set=self._config.bio_label_types)[0], dtype=torch.float)\n self._emiss_mat = torch.tensor(initialise_emissions(\n observations=intg_obs, label_set=self._config.bio_label_types,\n sources=self._config.sources, src_priors=self._config.src_priors\n )[0], dtype=torch.float)\n return self","def generate_features(self):\n content_input = self.content_image * 255\n style_input = self.style_image * 255\n preprocessed_content = tf.keras.applications.vgg19.preprocess_input(\n content_input)\n preprocessed_style = tf.keras.applications.vgg19.preprocess_input(\n style_input)\n outputs_content = self.model(preprocessed_content)\n outputs_style = self.model(preprocessed_style)\n\n num_style_layers = tf.size(self.style_layers)\n style_outputs, content_outputs = (\n outputs_style[:num_style_layers],\n outputs_content[num_style_layers:])\n\n style_outputs = [self.gram_matrix(\n style_output)for style_output in style_outputs]\n self.gram_style_features = style_outputs\n self.content_feature = content_outputs","def _build(self, z, targets= None, input_params = None):\n with tf.variable_scope (self.name + '_architecture') as scope:\n with tf.variable_scope ( 'generator') as scope:\n self.z = z\n self.targets =targets\n\n # Dot Product Layer 1\n par = input_params[0]\n process_params(par, name = self.name) \n par[0] = tf.transpose(par[0]) \n # Decoder ... \n decoder_1_out, params = dot_product_layer ( input = self.z, \n neurons = HIDDEN_2,\n params = par,\n name = 'gen_decoder_dot_1')\n g1_params = params\n \n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\n prob = self.dropout_prob,\n name = 'gen_dropout_1')\n\n # Dot Product Layer 2 \n par = input_params[1]\n process_params(par, name = self.name) \n par[0] = tf.transpose(par[0]) \n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \n neurons = HIDDEN_1,\n params = par,\n name = 'gen_decoder_dot_2')\n g2_params = params\n\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\n prob = self.dropout_prob,\n name = 'gen_dropout_2')\n\n # Dot Product Layer 3 \n par = input_params[2]\n process_params(par, name = self.name) \n par[0] = tf.transpose(par[0]) \n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \n neurons = 1250,\n params = par,\n name = 'gen_decoder_dot_0')\n g3_params = params\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N,\n name = 'gen_unflatten' )\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), \n name = 'gen_upsampling_1')\n\n # Convolution layer 1\n par = input_params[3]\n process_params(par, name = self.name) \n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\n neurons = CONV_1_N,\n filter_size = CONV_2_FILT,\n output_shape = (12,12),\n params = par, \n name = 'deconv_1' )\n\n g4_params = params\n\n # DeConv Layer 2\n par = input_params[4]\n process_params(par, name = self.name)\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), \n name = 'gen_upsampling_2')\n generated_images_square, params = deconv_2d_layer ( \n input = upsample_2,\n neurons = 1,\n filter_size = CONV_1_FILT,\n stride = (1,1,1,1),\n output_shape = (28,28),\n params = par, \n activation = 'tanh', \n name = 'conv_2' )\n \n g5_params = params\n self.generation = flatten_layer (generated_images_square, in_shp = [-1, 28, 28, 1])\n visualize_images(generated_images_square, name = 'generated_images')\n self.params = [g1_params, g2_params, g3_params, g4_params, g5_params]","def _build_forward_graph(self):\n\n print('[*] Building a Neural Turing Machine.')\n\n self._initalize_state()\n\n # present start token\n controller_out = self.controller.emit_feature_vector(self.start_token, self.r_t[0], reuse=None)\n self._read_write(controller_out, reuse=None)\n\n # present inputs\n print('Input chain: ')\n for t in range(0, self.sequence_length):\n print_progress(float(t + 1) / self.sequence_length)\n\n controller_out = self.controller.emit_feature_vector(self.inputs[t], self.r_t[-1], reuse=True)\n self._read_write(controller_out, reuse=True)\n\n # present end token\n controller_out = self.controller.emit_feature_vector(self.end_token, self.r_t[-1], reuse=True)\n self._read_write(controller_out, reuse=True)\n\n # present outputs\n print('Output chain: ')\n for t in range(0, self.sequence_length):\n print_progress(float(t + 1) / self.sequence_length)\n\n controller_out = self.controller.emit_feature_vector(self.zeros, self.r_t[-1], reuse=True)\n self._read_write(controller_out, reuse=True)\n\n reuse = None if t == 0 else True\n self.outputs.append(self._decode_read_vector(self.r_t[-1], reuse=reuse))\n print('Done.')","def _build_all_models(self):\r\n self.output_tensors = {}\r\n self.loss_terms = {}\r\n self.metrics = {}\r\n\r\n def _build_datasource_summaries(data_sources, mode):\r\n \"\"\"Register summary operations for input data from given data sources.\"\"\"\r\n with tf.variable_scope('%s_data' % mode):\r\n for data_source_name, data_source in data_sources.items():\r\n tensors = data_source.output_tensors\r\n for key, tensor in tensors.items():\r\n summary_name = '%s/%s' % (data_source_name, key)\r\n shape = tensor.shape.as_list()\r\n num_dims = len(shape)\r\n if num_dims == 4: # Image data\r\n if shape[1] == 1 or shape[1] == 3:\r\n self.summary.image(summary_name, tensor,\r\n data_format='channels_first')\r\n elif shape[3] == 1 or shape[3] == 3:\r\n self.summary.image(summary_name, tensor,\r\n data_format='channels_last')\r\n # TODO: fix issue with no summary otherwise\r\n elif num_dims == 2:\r\n self.summary.histogram(summary_name, tensor)\r\n else:\r\n logger.debug('I do not know how to create a summary for %s (%s)' %\r\n (summary_name, tensor.shape.as_list()))\r\n\r\n def _build_train_or_test(mode):\r\n data_sources = self._train_data if mode == 'train' else self._test_data\r\n\r\n # Build model\r\n output_tensors, loss_terms, metrics = self.build_model(data_sources, mode=mode)\r\n\r\n # Record important tensors\r\n self.output_tensors[mode] = output_tensors\r\n self.loss_terms[mode] = loss_terms\r\n self.metrics[mode] = metrics\r\n\r\n # Create summaries for scalars\r\n if mode == 'train':\r\n for name, loss_term in loss_terms.items():\r\n self.summary.scalar('loss/%s/%s' % (mode, name), loss_term)\r\n for name, metric in metrics.items():\r\n self.summary.scalar('metric/%s/%s' % (mode, name), metric)\r\n\r\n # Build the main model\r\n if len(self._train_data) > 0:\r\n _build_datasource_summaries(self._train_data, mode='train')\r\n _build_train_or_test(mode='train')\r\n logger.info('Built model.')\r\n\r\n # Print no. of parameters and lops\r\n flops = tf.profiler.profile(\r\n options=tf.profiler.ProfileOptionBuilder(\r\n tf.profiler.ProfileOptionBuilder.float_operation()\r\n ).with_empty_output().build())\r\n logger.info('------------------------------')\r\n logger.info(' Approximate Model Statistics ')\r\n logger.info('------------------------------')\r\n logger.info('FLOPS per input: {:,}'.format(flops.total_float_ops / self._batch_size))\r\n logger.info(\r\n 'Trainable Parameters: {:,}'.format(\r\n np.sum([np.prod(v.shape.as_list()) for v in tf.trainable_variables()])\r\n )\r\n )\r\n logger.info('------------------------------')\r\n\r\n # If there are any test data streams, build same model with different scope\r\n # Trainable parameters will be copied at test time\r\n if len(self._test_data) > 0:\r\n _build_datasource_summaries(self._test_data, mode='test')\r\n with tf.variable_scope('test'):\r\n _build_train_or_test(mode='test')\r\n logger.info('Built model for live testing.')\r\n\r\n if self._enable_live_testing:\r\n self._tester._post_model_build() # Create copy ops to be run before every test run\r","def construct(self):\n self.input_size = self.numplanes * self.boardsize**2\n \n if self.hidden:\n layers = [\n torch.nn.Linear(self.input_size, self.hidden), \n torch.nn.ReLU(),\n torch.nn.Linear(self.hidden, self.boardsize**2)\n ]\n else:\n layers = [torch.nn.Linear(self.input_size, self.boardsize**2)]\n\n self.layers = torch.nn.ModuleList(layers)\n self.optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)\n logging.info(\"Model initialized: %s\", self)","def main():\n g = CommanderGame([4, 3], 3)\n g.fit_army_orders()\n g.fit_game_matrix()\n g.show_submatrixes([\n [[4, 0, 0]],\n [[2, 1, 0], [1, 1, 1]],\n ])\n print(f'Full game matrix: \\n{g.game_matrix_}')","def process(self, mat):","def main():\n num_schedules = 150\n trainer = AutoEncoderTrain(num_schedules)\n trainer.train()\n trainer.compute_mean()\n trainer.create_iterables()\n\n trainer.round_each_encoding_and_create_array()\n trainer.populate_a_matrix_per_schedule()\n trainer.save_matrixes()","def matrix_generation(self, matrix_size, generate_to):\n matrix_A = np.random.randint(generate_to, size=(matrix_size, matrix_size))\n matrix_B = np.random.randint(generate_to, size=(matrix_size, matrix_size))\n # print(matrix_A)\n # print(matrix_B)\n # print(np.matmul(matrix_A, matrix_B))\n matrices = (matrix_A, matrix_B)\n return matrices","def build_model(self):\n import tensorflow as tf\n \n y = tf.nn.relu(tf.matmul(self.variables[\"input_observation\"], self.variables[\"W1\"]) + \n self.variables[\"b1\"], name=\"y1\")\n \n for i in range(self.n_hidden-1):\n y = tf.nn.relu(tf.matmul(y, self.variables[\"W\"+str(i+2)]) + \n self.variables[\"b\"+str(i+2)], name=\"y\"+str(i+2))\n \n self.variables[\"y\"] = [tf.matmul(y, self.variables[\"Wo_0\"]) + self.variables[\"bo_0\"]]\n for i in range(1, len(self.output_size)):\n self.variables[\"y\"] += [tf.matmul(y, self.variables[\"Wo_%s\"%i]) + self.variables[\"bo_%s\"%i]]","def compile(self):\n m, n = self.input_shape[1], self.input_shape[2]\n\n inp = Input(shape=self.input_shape, traces=True)\n self.add_layer(inp, \"DoG\")\n\n s1 = LIFNodes(shape=(18, m, n), traces=True)\n self.add_layer(s1, \"conv_1\")\n c1 = LIFNodes(shape=(18, m // 2, n // 2), traces=True)\n self.add_layer(c1, \"pool_1\")\n\n s2 = LIFNodes(shape=(24, m // 2, n // 2), traces=True)\n self.add_layer(s2, \"conv_2\")\n c2 = LIFNodes(shape=(24, m // 4, n // 4), traces=True)\n self.add_layer(c2, \"pool_2\")\n\n s3 = LIFNodes(shape=(32, m // 4, n // 4), traces=True)\n self.add_layer(s3, \"conv_3\")\n f = LIFNodes(shape=(32, 1), traces=True)\n self.add_layer(f, \"global_pool\")\n\n conv1 = Conv2dConnection(inp, s1, 5, padding=2, weight_decay=0.01,\n nu=0.01, update_rule=PostPre, decay=0.5)\n self.add_connection(conv1, \"DoG\", \"conv_1\")\n pool1 = MaxPool2dConnection(s1, c1, 2, 2, decay=0.5)\n self.add_connection(pool1, \"conv_1\", \"pool_1\")\n\n conv2 = Conv2dConnection(c1, s2, 3, padding=1, weight_decay=0.01,\n nu=0.01, update_rule=PostPre, decay=0.5)\n self.add_connection(conv2, \"pool_1\", \"conv_2\")\n pool2 = MaxPool2dConnection(s2, c2, 2, 2, decay=0.5)\n self.add_connection(pool2, \"conv_2\", \"pool_2\")\n\n conv3 = Conv2dConnection(c2, s3, 3, padding=1, weight_decay=0.01,\n nu=0.01, update_rule=PostPre, decay=0.5)\n self.add_connection(conv3, \"pool_2\", \"conv_3\")\n global_pool = MaxPool2dConnection(s3, f, (m // 4, n // 4), decay=0.5)\n self.add_connection(global_pool, \"conv_3\", \"global_pool\")\n\n monitor = NetworkMonitor(self, layers=[\"DoG\", \"conv_1\", \"pool_1\",\n \"conv_2\", \"pool_2\",\n \"conv_3\", \"global_pool\"],\n connections=[(\"DoG\", \"conv_1\"),\n (\"pool_1\", \"conv_2\"),\n (\"pool_2\", \"conv_3\")],\n state_vars=[\"w\", \"s\"])\n self.add_monitor(monitor, \"network_monitor\")\n\n return self","def generateMatrix(self):\n if self.tokenWeights and self.extraFeatures:\n nFeatures = self.wordId + self.wordId2 + len(self.EXTRA_WEIGHTS_LABELS)\n logging.info('Exporting TOKEN WEIGHTS AND EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n # iterate through 1st sentence\n for wId, val in doc['s1'].iteritems():\n mtrx[docId, wId] = val\n # then iterate thru 2nd sentence, store on 2ND PARTITION\n for wId, val in doc['s2'].iteritems():\n mtrx[docId, self.wordId + wId] = val\n # finally extra features values stored at the end of the vector\n for label, val in doc['extraFeatures'].iteritems():\n mtrx[docId, self.wordId + self.wordId2 + self.EXTRA_WEIGHTS_LABELS.index(label)] = val\n\n elif self.tokenWeights and not self.extraFeatures:\n nFeatures = self.wordId + self.wordId2\n logging.info('Exporting TOKEN WEIGHTS %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n # iterate through 1st sentence\n for wId, val in doc['s1'].iteritems():\n mtrx[docId, wId] = val\n # then iterate thru 2nd sentence, store on 2ND PARTITION\n for wId, val in doc['s2'].iteritems():\n mtrx[docId, self.wordId + wId] = val\n else:\n nFeatures = len(self.EXTRA_WEIGHTS_LABELS)\n logging.info('Exporting EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n for label, val in doc['extraFeatures'].iteritems():\n mtrx[docId, self.EXTRA_WEIGHTS_LABELS.index(label)] = val\n logging.info('Matrix generated')\n logging.info(mtrx.shape)\n return mtrx","def _export_model(self):\n graph = ComputeGraph.from_onnx(self.onnx_model.graph)\n\n print(\"Running constant propagation\")\n constant_states = constant_propagation(graph)\n\n self._remove_constants(graph, constant_states)\n self._remove_nops(graph, constant_states)\n\n # Add shape information from constant propagation:\n for var, res in constant_states.items():\n if var in graph.shape_dict:\n shape = graph.shape_dict[var]\n if res.shape != shape:\n print(\"Warning: Shapes do not match: \", var, res.shape, shape)\n if res.shape is not None:\n print(\"Replacing shape {} with {}\".format(shape, res.shape))\n graph.shape_dict[var] = res.shape\n elif res.shape is not None:\n graph.shape_dict[var] = res.shape\n\n print(\"Inference graph:\")\n for node in graph.nodes:\n inputs = node.inputs\n input_shapes = (str(graph.shape_dict[i]) for i in node.inputs if i in graph.shape_dict)\n outputs = node.outputs\n output_shapes = (str(graph.shape_dict[o]) for o in node.outputs if o in graph.shape_dict)\n print(\"{:<24} {:<20} {:<30} {:<30} {:<20} {:<30}\".format(node.name,\n node.op_type,\n \",\".join(inputs),\n \",\".join(input_shapes),\n \",\".join(outputs),\n \",\".join(output_shapes)))\n\n memory_manager = MemoryManager()\n\n self._generate_weights_file(graph)\n\n self.dummy_input = generate_dummy_main(graph)\n\n self.reference_input = generate_reference_main(graph)\n\n self._generate_network_initialization(graph, memory_manager)\n\n self._generate_network_cleanup(graph, memory_manager)\n\n implementations = self._select_implementations(graph, memory_manager)\n schedule = self._get_schedule(graph, implementations)\n # self._print_live_ranges(schedule)\n\n input_names = [\"input_\"+name.replace('.', '_').replace(':', '_').replace('/', '_')\n for name, type, shape in graph.inputs]\n output_names = [\"output_\"+name.replace('.', '_').replace(':', '_').replace('/', '_')\n for name, type, shape in graph.outputs]\n\n \"\"\"Currently we only allow single input (no batch processing) to the CNN, but this may be multi-channel input\"\"\"\n inputs = graph.inputs\n if len(inputs) > 1:\n print(\"ERROR: Multiple inputs not supported!\")\n exit(1)\n else:\n input_shape = graph.shape_dict[inputs[0].name]\n print(\"Input shape: {}\".format(input_shape))\n\n if len(input_shape) == 4:\n if input_shape[0] != 1:\n print(\"ERROR: Inference for batch_size > 1 currently not supported!\")\n exit(1)\n\n input_defs = [\"pico_cnn::naive::Tensor *\"+n for n in input_names]\n\n elif len(input_shape) == 3:\n if input_shape[0] != 1:\n print(\"ERROR: Inference for batch_size > 1 currently not supported!\")\n exit(1)\n\n input_defs = [\"pico_cnn::naive::Tensor *\"+n for n in input_names]\n\n elif len(input_shape) == 2:\n print(\"Input is one-dimensional (batch_size = 1 and num_input_channels = 1)\")\n input_defs = [\"pico_cnn::naive::Tensor *\"+n for n in input_names]\n\n outputs = graph.outputs\n if len(outputs) > 1:\n print(\"ERROR: Multiple outputs not supported\")\n exit(1)\n else:\n output_shape = graph.shape_dict[outputs[0].name]\n print(\"Output shape: {}\".format(output_shape))\n\n if len(output_shape) == 2:\n print(\"Output is one-dimensional (batch_size = 1 and num_input_channels = 1)\")\n output_defs = [\"pico_cnn::naive::Tensor *\" + n for n in output_names]\n elif len(output_shape) == 3:\n print(\"ERROR: Unknown output shape of network: {}\".format(output_shape))\n exit(1)\n elif len(output_shape) == 4:\n print(\"ERROR: Multi-dimensional output is currently not supported.\")\n exit(1)\n\n network_def = \"void Network::run(\" + \", \".join(input_defs) + \", \" + \", \".join(output_defs) + \")\"\n network_def_header = \"void run(\" + \", \".join(input_defs) + \", \" + \", \".join(output_defs) + \")\"\n\n layer_declaration_code = \"\"\n layer_allocation_code = \"\"\n layer_execution_code = \"\"\n layer_deletion_code = \"\"\n\n \"\"\"Iterate over all tasks in the schedule, put some debug info in the code and the pico-cnn implementation.\"\"\"\n for task in schedule:\n num, node, impl = task\n layer_allocation_code += \" //Layer \" + str(num) + \" \" + node.name + \" \" + node.op_type + \"\\n\"\n layer_allocation_code += \" //Attributes\\n\"\n for key, val in node.attrs.items():\n layer_allocation_code += \" // \" + str(key) + \": \" + str(val) + \"\\n\"\n layer_allocation_code += \" //Parameters\\n\"\n layer_allocation_code += \" //Inputs: \" + \",\".join(node.inputs) + \"\\n\"\n layer_allocation_code += \" //Outputs: \" + \",\".join(node.outputs) + \"\\n\"\n layer_allocation_code += \" //Shape:\\n\"\n for i in node.inputs:\n layer_allocation_code += \" // {}: {}\\n\".format(i, graph.get_shape(i))\n for o in node.outputs:\n layer_allocation_code += \" // {}: {}\\n\".format(o, graph.get_shape(o))\n\n if impl:\n layer_declaration_code += impl.generate_declaration()\n layer_declaration_code += \"\\n\"\n\n layer_allocation_code += impl.generate_allocation()\n layer_allocation_code += \"\\n\"\n\n layer_execution_code += impl.generate_execution()\n layer_execution_code += \"\\n\"\n\n layer_deletion_code += impl.generate_deletion()\n layer_deletion_code += \"\\n\"\n\n else:\n print(\"ERROR: Unsupported layer: {}! Aborting code generation.\".format(node.op_type))\n return 1\n\n self.constructor_code += layer_allocation_code + \"\\n\"\n self.destructor_code += layer_deletion_code + \"\\n\"\n\n # # TODO: What does this loop do?\n # for id, buffer in memory_manager.buffers.items():\n # if graph.is_tensor(id):\n # continue\n # if graph.is_input(id):\n # continue\n # if graph.is_output(id):\n # continue\n\n network_code: Text = \"#include \\\"network.h\\\"\\n\\n\"\n network_code += \"Network::Network() {\\n\\n\"\n network_code += self.constructor_code + \"\\n\"\n network_code += \"}\\n\\n\"\n network_code += \"Network::~Network() {\\n\"\n network_code += self.destructor_code + \"\\n\"\n network_code += \"}\\n\\n\"\n network_code += network_def+\"{\\n\"\n network_code += layer_execution_code\n\n network_code += \"}\\n\\n\"\n\n network_header = \"#ifndef NETWORK_H\\n\"\n network_header += \"#define NETWORK_H\\n\\n\"\n network_header += \"#include \\\"pico-cnn/pico-cnn.h\\\"\\n\\n\"\n network_header += \"class Network {\\n\"\n network_header += \"public:\\n\"\n network_header += \"Network();\\n\"\n network_header += \"~Network();\\n\"\n network_header += network_def_header + \"; \\n\\n\"\n network_header += self.buffer_declaration + \"\\n\"\n network_header += layer_declaration_code\n network_header += \"};\\n\"\n network_header += \"#endif //NETWORK_H\\n\"\n\n self.network_code = network_code\n self.network_header = network_header\n\n \"\"\"\n Create Makefile containing a target for the generated dummy input and a network specific one.\n The code for the network specific input has to be written manually.\n \"\"\"\n # TODO: Does this need to be more sophisticated?\n self.makefile = \"CC = g++\\n\"\n self.makefile += \"CFLAGS = -std=c++11 -Wall -O2 -march=native -DINFO\\n\"\n self.makefile += \"LDFLAGS = -L../../../pico-cnn\\n\"\n self.makefile += \"LD_LIBS = -lpico-cnn -lm\\n\\n\"\n self.makefile += \"# list of all generated .cpp files.\\n\"\n self.makefile += \"NETWORK_LIST = network.cpp\"\n self.makefile += \"\\n\\ndummy_input: dummy_input.cpp $(NETWORK_LIST) libpico-cnn.a\\n\\t\"\n self.makefile += \"$(CC) dummy_input.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) $(LDFLAGS) $(LD_LIBS) -o dummy_input\"\n self.makefile += \"\\n\\nreference_input: reference_input.cpp $(NETWORK_LIST) libpico-cnn.a\\n\\t\"\n self.makefile += \"$(CC) reference_input.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) \" \\\n \"$(LDFLAGS) $(LD_LIBS) -o reference_input\"\n self.makefile += \"\\n\\n{}: {}.cpp $(NETWORK_LIST) libpico-cnn.a\\n\\t\".format(self.model_name, self.model_name)\n self.makefile += \"$(CC) {}.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) \" \\\n \"$(LDFLAGS) $(LD_LIBS) -o {}\".format(self.model_name, self.model_name)\n self.makefile += \"\\n\\nall: dummy_input reference_input {}\".format(self.model_name)\n self.makefile += \"\\n\\n.PHONY: clean\\n\"\n self.makefile += \"clean:\\n\\trm -rf {} dummy_input reference_input\\n\".format(self.model_name)\n self.makefile += \"\\n\\n.PHONY: libpico-cnn.a\\n\"\n self.makefile += \"libpico-cnn.a:\\n\\t$(MAKE) -C ../../../pico-cnn\"\n\n self.save(\"./generated_code/{}\".format(self.model_name))","def create_start_data(self):\n\t\tdef inputMesh(feature_size):\n\t\t\tc1= np.expand_dims(np.array([0,-0.9]),0)\n\t\t\tc2= np.expand_dims(np.array([-0.9,0.9]),0)\n\t\t\tc3= np.expand_dims(np.array([0.9,0.9]),0)\n\t\t\tx1 = np.expand_dims(np.pad(np.array([0,-0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\n\t\t\tx2 = np.expand_dims(np.pad(np.array([-0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\n\t\t\tx3 = np.expand_dims(np.pad(np.array([0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\n\t\t\tedge_index = np.transpose(np.array([[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]])) # COO format\n\t\t\treturn np.concatenate((c1,c2,c3),axis=0), np.concatenate((x1,x2,x3),axis=0),edge_index\n\n\t\tc, x, edge_index = inputMesh(self.params.feature_size)# x is c with zeros appended, x=f ..pixel2mesh\n\t\tdata_list_x = []\n\t\tdata_list_c = []\n\t\tdata_list_pid = []\n\t\tfor i in range(self.params.batch_size):\n\t\t\tdata_list_x.append(Data(x=torch.Tensor(x).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\n\t\t\tdata_list_c.append(Data(x=torch.Tensor(c).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\n\t\t\tdata_list_pid.append(Data(x=torch.zeros(c.shape[0],1).type(dtypeL).requires_grad_(False)))\n\t\tbatch_x = Batch.from_data_list(data_list_x)\n\t\tbatch_c = Batch.from_data_list(data_list_c)\n\t\tbatch_pid = Batch.from_data_list(data_list_pid)\n\t\treturn batch_x, batch_c, batch_pid","def create_modules(self):\n self.bitcell = self.replica_bitcell = self.mod_replica_bitcell()\n self.add_mod(self.bitcell)\n\n # This is the replica bitline load column that is the height of our array\n self.rbl = bitcell_array(name=\"bitline_load\", cols=1, rows=self.bitcell_loads)\n self.add_mod(self.rbl)\n\n # FIXME: The FO and depth of this should be tuned\n self.delay_chain = self.mod_delay_chain([self.delay_fanout]*self.delay_stages)\n self.add_mod(self.delay_chain)\n\n self.inv = pinv()\n self.add_mod(self.inv)\n\n self.access_tx = ptx(tx_type=\"pmos\")\n self.add_mod(self.access_tx)","def run(layers):","def process(self):\n # Opening and preprocessing of the input file\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\n if self.options.mbtiles_fromdisk:\n i_parm=10\n if self.options.mbtiles_todisk:\n i_parm=11\n if self.options.verbose:\n print \"GDAL2MbTiles :mbtiles from/to disk [\",i_parm,\"] mbtiles_fromdisk[\",self.options.mbtiles_fromdisk,\"] mbtiles_todisk[\",self.options.mbtiles_todisk,\"]\"\n self.mbtiles_setup(i_parm)\n return\n else:\n if self.options.verbose:\n print \"GDAL2MbTiles :tile creation mbtiles[\",self.options.mbtiles,\"]\"\n self.open_input()\n # Generation of main metadata files and HTML viewers\n self.generate_metadata()\n # Generation of the lowest tiles\n self.generate_base_tiles()\n # Generation of the overview tiles (higher in the pyramid)\n self.generate_overview_tiles()\n # Generating of KML\n self.generate_kml()","def CreateDesignMatrix_X(z, x, y, n ):\n if len(x.shape) > 1:\n x = np.ravel(x)\n y = np.ravel(y)\n\n N = len(x)\n l = int((n+1)*(n+2)/2) \n X = np.ones((N,l))\n\n for i in range(1,n+1):\n q = int((i)*(i+1)/2)\n for k in range(i+1):\n X[:,q+k] = x**(i-k) * y**k\n \n X, z_, indicies = shuffle(X, z)\n X_train, X_test, z_train, z_test = train_test_split(X, z_, test_size=split_train_test, random_state=seed, shuffle=False)\n X_test, X_val, z_test, z_val = train_test_split(X_test, z_test, test_size=split_test_val, random_state=seed, shuffle=False)\n\n return X, X_train, X_test, X_val, z_train, z_test, z_val, indicies","def _setup(self) -> None:\n #TODO: type\n self.activation = self.params['activation']\n\n self.batchsize: int = self.params['batchsize']\n\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\n\n self.d: int = self.input_shape[1]\n assert(not self.d == 0)\n\n self.n: int = int(sqrt(self.input_shape[2]))\n assert(not self.n == 0)\n\n self.dtype: type = self.params['dtype']\n\n # initialize weights\n self.W: List[tf.Tensor] = []\n \n for i in range(3):\n #TODO: type\n w_init = self.params['initializer_w']\n if self.params['initializer_w' + str(i)] is not None:\n w_init = self.params['initializer_w' + str(i)]\n\n w_stddev: float = self.params['stddev_w']\n if self.params['stddev_w' + str(i)] is not None:\n w_stddev = self.params['stddev_w' + str(i)]\n\n self.W.append(tf.get_variable(\"weights_\" + str(i),\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\n dtype = self.dtype,\n initializer = w_init(stddev=w_stddev)))\n\n #TODO: type\n b_init = self.params['initializer_b']\n b_stddev = self.params['stddev_b']\n self.B: tf.Tensor = tf.get_variable(\"biases\", shape = (1, self.d, 1),\n dtype = self.dtype,\n initializer = b_init(stddev=b_stddev))\n\n # create/load expand matrix\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\n self.expand: tf.Tensor = tf.get_variable(\n \"expand\" + str(self.n),\n shape = (self.n, self.n * self.n),\n dtype = self.dtype,\n initializer = tf.constant_initializer(make_expand(self.n)))\n\n # create/load tile matrix\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\n for i in range(1, self.n):\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\n\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)","def generate_map(self):\n\n # Create main streets first\n self.create_main_streets()\n\n # Then create the commercial buildings in the center of town\n self.create_commercial_center()\n\n # Then create the neighborhoods that populate the rest of the city\n while(self.create_neighborhood()):\n pass\n\n # Clean up any invalid buildings that were created\n self.delete_inaccessible_buildings()","def build(self):\n if self.is_built:\n return\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n #self.names = []\n self.nelements //= self.ntimes\n\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n self.node_element = np.zeros((self.ntotal, 2), dtype=idtype)\n #oxx, oyy, txy, angle, major, minor, ovm\n self.data = np.zeros((self.ntimes, self.nelements, 8), dtype=fdtype)\n self.location = np.empty(self.ntotal, dtype='U8')\n\n self._times = np.zeros(self.ntimes, dtype=dtype)","def create_grids(self):\n \n par = self.par\n\n # a. retirement\n \n # pre-decision states\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\n \n # post-decision states\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\n \n # b. working: state space (m,n,k) \n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\n\n par.Nn = par.Nm\n par.n_max = par.m_max + par.n_add\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\n\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\n\n # c. working: w interpolant (and wa and wb and wq)\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\n par.a_max = par.m_max + par.a_add\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\n \n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\n par.b_max = par.n_max + par.b_add\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\n \n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\n \n # d. working: egm (seperate grids for each segment)\n \n if par.solmethod == 'G2EGM':\n\n # i. dcon\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\n \n # ii. acon\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\n par.a_acon = np.zeros(par.grid_b_acon.shape)\n par.b_acon = par.grid_b_acon\n\n # iii. con\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\n \n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\n\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\n par.a_con = np.zeros(par.c_con.shape)\n par.d_con = np.zeros(par.c_con.shape)\n \n elif par.solmethod == 'NEGM':\n\n par.grid_l = par.grid_m\n\n # e. shocks\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\n\n if par.Neta > 1:\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\n else:\n par.eta = np.ones(1)\n par.w_eta = np.ones(1)\n\n # f. timings\n par.time_work = np.zeros(par.T)\n par.time_w = np.zeros(par.T)\n par.time_egm = np.zeros(par.T)\n par.time_vfi = np.zeros(par.T)","def test_matrix_shapes(self):\n k = [2, 3, 4, 5, 6]\n mn = self.create_chain_model(k)\n\n max_states = max(k)\n\n assert mn.matrix_mode is False, \"Matrix mode flag was set prematurely\"\n\n mn.create_matrices()\n\n assert mn.matrix_mode, \"Matrix mode flag wasn't set correctly\"\n\n assert mn.unary_mat.shape == (max_states, 5)","def get_all_coding_matrices(self):\n class tran_matrix():\n def __init__(self):\n self.S = None\n self.T = None\n self.H1 = None\n self.H2 = None\n self.G1 = None\n self.G2 = None\n self.H = None\n self.H2G2 = None\n\n def __init__(self, S, T, H1, H2, G1, G2, H, H2G2):\n self.S = S\n self.T = T\n self.H1 = H1\n self.H2 = H2\n self.G1 = G1\n self.G2 = G2\n self.H = H\n self.H2G2 = H2G2\n\n s = self.sources\n s_edges = [self.out_edges(x) for x in s]\n S = [list(set(self.get_edges_indices(src))) for src in s_edges]\n\n matrices = []\n for dsts in self.dst_evolution_rec[::-1]:\n T = [sorted(x) for x in dsts]\n H2_raw = self.coding_matrix[T[0]].ix[S[1]].values\n G2_raw = self.coding_matrix[T[1]].ix[S[1]].values\n H1 = numpy_to_generic(self.coding_matrix[T[0]].ix[S[0]].values)\n H2 = numpy_to_generic(H2_raw)\n G1 = numpy_to_generic(self.coding_matrix[T[1]].ix[S[0]].values)\n G2 = numpy_to_generic(G2_raw)\n H = numpy_to_generic(self.coding_matrix[T[0]].values)\n H2G2 = numpy_to_generic(np.hstack((H2_raw, G2_raw)))\n temp = tran_matrix(S, T, H1, H2, G1, G2, H, H2G2)\n matrices.append(temp)\n\n return matrices","def __set_transform_matrices(self):\n self.tf_matrices_list = []\n\n transform_matrix = eye(4) # creates a unit matrix via passing argument.\n for i in range(self.joint_count):\n transform_matrix = transform_matrix * self.__create_tf_matrix(self.alpha[i], self.a[i], self.d[i], self.q[i]).subs(self.dh_params)\n self.tf_matrices_list.append(transform_matrix)","def main(self):\n if self.mode==0: #drawing\n self.draw()\n self.graph_drawing=self.cleanGraph(self.graph_drawing)\n #if len(self.graph_drawing)>1:\n # self.function_interpolation=self.polynomialInterpolation2D(self.graph_drawing,1)\n # self.graph_interpolation=self.sample(self.function_interpolation,len(self.graph_drawing))\n elif self.mode==1: #construction\n self.step+=1\n self.time=self.step/self.max_step\n if self.step>self.max_step:\n self.mode=2\n #self.graph_construction=self.discreteComplexComposeGraph(self.coefficients,self.time) #complex now\n self.graph_construction=self.numpyComposeConstructionGraph(self.coefficients,t=self.time)\n self.vectors=self.getVectors([(0,0)]+self.graph_construction)\n self.graph_display.append(self.graph_construction[-1])\n\n elif self.mode==2:\n self.draw()","def assemble_matrices(self):\n \n #Pointer reassignment for convenience\n N = self.ngrids\n\n #Begin with a linked-list data structure for the transmissibilities,\n #and one-dimenstional arrays for the diagonal of B and the flux vector\n T = lil_matrix((N, N), dtype=np.double)\n B = np.zeros(N, dtype=np.double)\n Q = np.zeros(N, dtype=np.double)\n\n #Read in boundary condition types and values\n bcs = self.input_data['boundary conditions']\n bc_type_1 = bcs['left']['type'].lower()\n bc_type_2 = bcs['right']['type'].lower()\n bc_value_1 = bcs['left']['value']\n bc_value_2 = bcs['right']['value']\n \n #Loop over all grid cells\n for i in range(N):\n\n #Apply left BC\n if i == 0:\n T[i, i+1] = -self.compute_transmissibility(i, i + 1)\n\n if bc_type_1 == 'neumann':\n T[i, i] = T[i,i] - T[i, i+1]\n elif bc_type_1 == 'dirichlet':\n #Computes the transmissibility of the ith block\n T0 = self.compute_transmissibility(i, i)\n T[i, i] = T[i,i] - T[i, i+1] + 2.0 * T0\n Q[i] = 2.0 * T0 * bc_value_1\n else:\n pass #TODO: Add error checking here if no bc is specified\n\n #Apply right BC\n elif i == (N - 1):\n T[i, i-1] = -self.compute_transmissibility(i, i - 1)\n\n if bc_type_2 == 'neumann':\n T[i, i] = T[i,i] - T[i, i-1]\n elif bc_type_2 == 'dirichlet':\n #Computes the transmissibility of the ith block\n T0 = self.compute_transmissibility(i, i)\n T[i, i] = T[i, i] - T[i, i-1] + 2.0 * T0\n Q[i] = 2.0 * T0 * bc_value_2\n else:\n pass #TODO:Add error checking here if no bc is specified\n\n #If there is no boundary condition compute interblock transmissibilties\n else:\n T[i, i-1] = -self.compute_transmissibility(i, i-1)\n T[i, i+1] = -self.compute_transmissibility(i, i+1)\n T[i, i] = (self.compute_transmissibility(i, i-1) +\n self.compute_transmissibility(i, i+1))\n\n #Compute accumulations\n B[i] = self.compute_accumulation(i)\n\n #If constant-rate wells are present, add them to the flux vector\n if self.rate_well_grids is not None:\n Q[self.rate_well_grids] += self.rate_well_values\n\n \n #Return sparse data-structures\n return (T.tocsr(), \n csr_matrix((B, (np.arange(N), np.arange(N))), shape=(N,N)), \n Q)","def run(self):\n super().run()\n # more verbose creation date for clarity\n creation_date = f'20{self.creation_date}'\n make_e3sm_to_cmip_maps(self.config, self.logger, self.mesh_short_name,\n creation_date, self.ntasks)","def build(self, input_shape):\n\n # get shape of input matrix x\n self.num_of_vertices = input_shape[1]\n self.num_of_features = input_shape[2]\n self.num_of_timesteps = input_shape[3]\n #self.W_1.shape = (num_of_timesteps,)\n #self.W_2.shape = (num_of_features, num_of_timesteps)\n #self.W_3.shape = (num_of_features,)\n #self.b_s.shape = (1, num_of_vertices, num_of_vertices)\n #self.V_s.shape = (num_of_vertices, num_of_vertices)\n\n self.w1 = self.add_weight(name='w1', shape=(self.num_of_timesteps, ),\n initializer='glorot_normal', trainable=True)\n self.w2 = self.add_weight(name='w2', shape=(self.num_of_features, self.num_of_timesteps),\n initializer='glorot_normal', trainable=True)\n self.w3 = self.add_weight(name='w3', shape=(self.num_of_features,),\n initializer='glorot_normal', trainable=True)\n self.b = self.add_weight(name='b', shape=(1, self.num_of_vertices, self.num_of_vertices),\n initializer='zeros', trainable=True)\n self.v = self.add_weight(name='v', shape=(self.num_of_vertices, self.num_of_vertices),\n initializer='glorot_normal', trainable=True)\n\n super(Spatial_Attention_layer, self).build(input_shape)","def model(inputs):\n outputs = {}\n\n # First, build the encoder\n encoder_fn = _get_network(params.encoder_name)\n with tf.variable_scope('encoder', reuse=reuse):\n # Produces id/pose units\n enc_outputs = encoder_fn(inputs['images_1'], params, is_training)\n outputs['ids_1'] = enc_outputs['ids']\n\n # Second, build the decoder and projector\n decoder_fn = _get_network(params.decoder_name)\n with tf.variable_scope('decoder', reuse=reuse):\n outputs['voxels_1'] = decoder_fn(outputs['ids_1'], params, is_training)\n if run_projection:\n projector_fn = _get_network(params.projector_name)\n with tf.variable_scope('projector', reuse=reuse):\n outputs['projs_1'] = projector_fn(\n outputs['voxels_1'], inputs['matrix_1'], params, is_training)\n # Infer the ground-truth mask\n with tf.variable_scope('oracle', reuse=reuse):\n outputs['masks_1'] = projector_fn(inputs['voxels'], inputs['matrix_1'],\n params, False)\n\n # Third, build the entire graph (bundled strategy described in PTN paper)\n for k in range(1, params.step_size):\n with tf.variable_scope('projector', reuse=True):\n outputs['projs_%d' % (k + 1)] = projector_fn(\n outputs['voxels_1'], inputs['matrix_%d' %\n (k + 1)], params, is_training)\n with tf.variable_scope('oracle', reuse=True):\n outputs['masks_%d' % (k + 1)] = projector_fn(\n inputs['voxels'], inputs['matrix_%d' % (k + 1)], params, False)\n\n return outputs","def generate(self, n_enemies, n_blocks):\n self.create_map()\n self.create_floor()\n self.player = self.create_player_at(0, 0)\n self.create_dummy_obj_at(0, 1)\n self.create_dummy_obj_at(1, 0)\n self.create_soft_block_at(0, 2)\n self.create_soft_block_at(2, 0)\n self.create_hard_blocks() \n self.create_enemies(n_enemies)\n self.create_soft_blocks(n_blocks) \n self.clear_dummy_obj()","def build(self, input_shape):\n\n # get shape of input matrix x\n num_of_vertices = input_shape[1]\n num_of_features = input_shape[2]\n num_of_timesteps = input_shape[3]\n #self.U_1.shape = (num_of_vertices,)\n #self.U_2.shape = (num_of_features, num_of_vertices)\n #self.U_3.shape = (num_of_features,)\n #self.b_e.shape = (1, num_of_timesteps, num_of_timesteps)\n #self.V_e.shape = (num_of_timesteps, num_of_timesteps)\n\n self.u1 = self.add_weight(name='u1', shape=(num_of_vertices, ),\n initializer='glorot_normal', trainable=True)\n self.u2 = self.add_weight(name='u2', shape=(num_of_features, num_of_vertices),\n initializer='glorot_normal', trainable=True)\n self.u3 = self.add_weight(name='u3', shape=(num_of_features,),\n initializer='glorot_normal', trainable=True)\n self.b = self.add_weight(name='b', shape=(1, num_of_timesteps, num_of_timesteps),\n initializer='zeros', trainable=True)\n self.v = self.add_weight(name='v', shape=(num_of_timesteps, num_of_timesteps),\n initializer='glorot_normal', trainable=True)\n\n super(Temporal_Attention_layer, self).build(input_shape)","def synthetic_gen(self):\r\n logging.debug('generating synthetic map...')\r\n data = self.realData\r\n unit = Params.unitGrid\r\n x_min = np.floor(Params.LOW[0] / unit) * unit\r\n x_max = np.ceil(Params.HIGH[0] / unit) * unit\r\n y_min = np.floor(Params.LOW[1] / unit) * unit\r\n y_max = np.ceil(Params.HIGH[1] / unit) * unit\r\n\r\n x_CELL = int(np.rint((x_max - x_min) / unit))\r\n y_CELL = int(np.rint((y_max - y_min) / unit))\r\n\r\n self.root.n_box = np.array([[x_min, y_min], [x_max, y_max]])\r\n\r\n self.mapp = np.zeros((x_CELL, y_CELL)) - 1 # ## initialize every cell with -1\r\n for i in range(Params.NDATA): # ## populate the map\r\n point = data[:, i]\r\n cell_x = int(np.floor((point[0] - x_min) / unit))\r\n cell_y = int(np.floor((point[1] - y_min) / unit))\r\n if self.mapp[cell_x, cell_y] != -1:\r\n self.mapp[cell_x, cell_y] += 1\r\n else:\r\n self.mapp[cell_x, cell_y] = 1\r\n\r\n for i in range(x_CELL): # ## perturb the counts\r\n for j in range(y_CELL):\r\n if self.mapp[i, j] != -1:\r\n self.mapp[i, j] += np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\r\n else:\r\n self.mapp[i, j] = np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\r\n # if noisy count is negative, ignore the noise and generate no points\r\n if self.mapp[i, j] < 0:\r\n self.mapp[i, j] = 0","def _generate_weighted_matrices(self):\n self.degree_weighted_matrices = dict()\n mes = []\n args = []\n for metaedge, matrix in self.adj_matrices.items():\n mes.append(metaedge)\n args.append({'matrix': matrix, 'w': self.w, 'degree_fwd': self.out_degree[metaedge],\n 'degree_rev': self.in_degree[metaedge]})\n res = parallel_process(array=args, function=mt.weight_by_degree, use_kwargs=True, n_jobs=self.n_jobs,\n front_num=0)\n for metaedge, matrix in zip(mes, res):\n self.degree_weighted_matrices[metaedge] = matrix"],"string":"[\n \"def assembleMatrices(self):\\n # All nodes informations\\n self.aircraftNodesPoints = []\\n self.aircraftMassPoints = []\\n self.aircraftMassDistances = []\\n self.aircraftSegmentsLengths = []\\n self.aircraftNodesNames = []\\n self.aircraftInitNodesAreas = []\\n self.aircraftNodesA = []\\n self.aircraftNodesIy = []\\n self.aircraftNodesIz = []\\n self.aircraftNodesJ = []\\n # More general information\\n self.aircraftConnectedNodes = []\\n self.aircraftNonRotatingNodes = []\\n\\n self.computeProportionFuselage()\\n self.computeProportionWings()\\n\\n # adds fulseage infos to matrices if there is one\\n if self.nFuselage > 0:\\n self.aircraftNodesPoints.append(self.fs_m_points[0])\\n # Assumption is made that for a fuselage section, its cog is\\n # aligned with the section center.\\n self.aircraftMassPoints.append(self.fs_m_points[0])\\n self.aircraftMassDistances.append(np.zeros((len(self.fs_m_points[0]),3)))\\n self.aircraftSegmentsLengths.append(self.fs_m_distanceBetweenPoints[0])\\n self.aircraftNodesNames.append(self.fs_m_pointsName[0])\\n self.aircraftInitNodesAreas.append(self.fs_m_pointsInitArea[0])\\n self.aircraftNodesA.append(self.fs_m_pointsA[0])\\n self.aircraftNodesIy.append(self.fs_m_pointsIy[0])\\n self.aircraftNodesIz.append(self.fs_m_pointsIz[0])\\n self.aircraftNodesJ.append(self.fs_m_pointsJ[0])\\n logger.debug('\\\\n')\\n for i in range(self.nWings):\\n self.aircraftNodesPoints.append(self.ws_me_points[i])\\n self.aircraftMassPoints.append(self.ws_ma_points[i])\\n self.aircraftMassDistances.append(self.ws_ma_distance[i])\\n self.aircraftSegmentsLengths.append(self.ws_me_distances[i])\\n # logger.debug(i)\\n # logger.debug(self.ws_me_distances)\\n # logger.debug(self.aircraftSegmentsLengths)\\n self.aircraftNodesNames.append(self.ws_me_pointsName[i])\\n self.aircraftInitNodesAreas.append(self.ws_me_pointsInitArea[i])\\n self.aircraftNodesA.append(self.ws_me_pointsA[i])\\n self.aircraftNodesIy.append(self.ws_me_pointsIy[i])\\n self.aircraftNodesIz.append(self.ws_me_pointsIz[i])\\n self.aircraftNodesJ.append(self.ws_me_pointsJ[i])\\n self.computeMass()\",\n \"def generate_image_matrices():\\r\\n for i in range(int(number_of_matrices.get())):\\r\\n clear_space()\\r\\n populate_image_lists()\\r\\n randomly_select_images()\\r\\n get_image_data()\\r\\n grid_frame = Image.new(\\\"RGB\\\", (matrix_x_pix, matrix_y_pix), \\\"white\\\")\\r\\n image_index = 0\\r\\n for j in range(matrix_x):\\r\\n for k in range(matrix_y):\\r\\n img = Image.open(images_total[image_index])\\r\\n grid_frame.paste(img, (padding + (j * (padding + image_x)),\\r\\n padding + (k * (padding + image_y))))\\r\\n image_index += 1\\r\\n\\r\\n save_path = (os.path.join(dir_path, \\\"outputs\\\\\\\\\\\") +\\r\\n number_of_images_a.get() + \\\"a\\\" +\\r\\n number_of_images_b.get() + \\\"b_img\\\" + str(i) + \\\".png\\\")\\r\\n grid_frame.save(save_path, \\\"PNG\\\")\",\n \"def make_all(self):\\n # General matrices #\\n self.tsv_seq_to_concepts()\\n self.tsv_seq_to_names()\\n self.list_sequence_concept()\\n # Only in the with 'samples' case #\\n if self.a.abundances: self.tsv_samples_to_names()\\n if self.a.abundances: self.biom_output()\\n # Graphical outputs #\\n self.per_seq_dot_files()\\n if self.a.abundances: self.per_sample_dot_files()\",\n \"def _derive_transformation_matrices(self):\\n\\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\\n if self._primaries is not None and self._whitepoint is not None:\\n npm = normalised_primary_matrix(self._primaries,\\n self._whitepoint)\\n\\n self._derived_RGB_to_XYZ_matrix = npm\\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)\",\n \"def build(self):\\n self.build_inputs()\\n self.build_word_embeddings()\\n self.build_encoder()\\n self.build_fc()\\n self.build_loss()\\n self.build_global_step()\",\n \"def build_matrix(self):\\n self.lb_make = LabelEncoder()\\n self.lb_make.fit(self.Y_train)\\n tokenizer = Tokenizer(num_words=2000)\\n x_array_train = numpy.asarray(self.train['text'])\\n x_array_test = numpy.asarray(self.test['text'])\\n tokenizer.fit_on_texts(x_array_train)\\n x_train_matrix = tokenizer.texts_to_matrix(x_array_train, mode='count')\\n x_test_matrix = tokenizer.texts_to_matrix(x_array_test, mode='count')\\n y_train_numbers = self.lb_make.transform(self.Y_train)\\n y_test_numbers = self.lb_make.transform(self.Y_test)\\n y_train_matrix = keras.utils.to_categorical(y_train_numbers, 3)\\n y_test_matrix = keras.utils.to_categorical(y_test_numbers, 3)\\n self.tokenizer = tokenizer\\n return x_train_matrix, x_test_matrix, y_train_matrix, y_test_matrix\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def build_graph(self):\\n self.__create_placeholders()\\n self.__create_encoder()\\n self.__create_latent()\\n self.__create_decoder()\\n self.__create_loss()\\n self.__create_generate()\\n self.__create_reconstruct()\\n self.__create_optimizer()\\n self.__create_summary()\",\n \"def build_graph(self):\\n\\t\\tself._create_placeholders()\\n\\t\\tself._create_embedding()\\n\\t\\tself._create_recurrent_layers()\\n\\t\\tself._create_de_embedding()\\n\\t\\tself._create_loss()\\n\\t\\tself._create_optimizer()\\n\\t\\tself._create_summaries()\",\n \"def create_matrices(self):\\n debut = time.process_time()\\n\\n x = np.arange(0, self.axe_X)\\n y = np.arange(0, self.axe_Y)\\n xv, yv = np.meshgrid(x, y)\\n\\n print(\\\"\\\\nmatrix creation estimation time: %.1fs\\\" % (1e-6*self.axe_X*self.axe_Y))\\n\\n img_matrix_x, img_matrix_y = self.find_position(xv, yv)\\n\\n fin = time.process_time()\\n print(\\\"matrix created in time: %.1f s\\\" % (fin-debut))\\n return img_matrix_x, img_matrix_y\",\n \"def _generate_network_initialization(self, graph, memory_manager):\\n\\n # TODO: To be changed if we want to support multiple outputs\\n output_buffer_name = graph.outputs[0].name\\n\\n ops_to_ignore = ['Reshape', 'Mul']\\n\\n buffers_allocated = []\\n\\n buffer_declaration = \\\"\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **kernels;\\\\n\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **biases;\\\\n\\\"\\n\\n constructor_code = \\\"\\\"\\n #constructor_code += \\\"Network::Network() {\\\\n\\\\n\\\"\\n\\n num_layers = 0\\n num_kernels = 0\\n num_biases = 0\\n\\n for node in graph.nodes:\\n \\\"\\\"\\\"Do not count the reshape layers as the input tensor will only define the dimensions\\\"\\\"\\\"\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n num_layers += 1\\n for num, input in enumerate(node.input_tensors):\\n if input in buffers_allocated:\\n continue\\n else:\\n tensor = node.input_tensors[input]\\n buffers_allocated.append(input)\\n if len(tensor.shape) == 1:\\n num_biases += 1\\n else:\\n num_kernels += 1\\n\\n \\\"\\\"\\\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\\\"\\\"\\\"\\n constructor_code += \\\" kernels = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\".format(num_kernels)\\n constructor_code += \\\" biases = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\\n\\\".format(num_biases)\\n\\n pos = -1\\n pos_kernel = -1\\n pos_bias = -1\\n\\n buffers_allocated.clear()\\n\\n \\\"\\\"\\\"Iterate over all nodes in the graph and generate the corresponding allocation code.\\\"\\\"\\\"\\n for node_id, node in enumerate(graph.nodes):\\n\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n pos += 1\\n\\n buffer_declaration += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n constructor_code += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n\\n # Allocate memory for kernels and biases\\n buffer_declaration += \\\" // Inputs\\\\n\\\"\\n constructor_code += \\\" // Inputs\\\\n\\\"\\n for num, input in enumerate(node.input_tensors):\\n\\n if node.op_type in ops_to_ignore:\\n continue\\n\\n if input in buffers_allocated:\\n continue\\n else:\\n buffers_allocated.append(input)\\n\\n tensor = node.input_tensors[input]\\n if len(tensor.shape) == 1:\\n pos_bias += 1\\n else:\\n pos_kernel += 1\\n\\n buffer = memory_manager.get_buffer(graph, input)\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"KernelAllocation\\\")\\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\" // Outputs\\\\n\\\"\\n constructor_code += \\\" // Outputs\\\\n\\\"\\n for num, output in enumerate(node.outputs):\\n\\n buffer = memory_manager.get_buffer(graph, output)\\n\\n if output == output_buffer_name:\\n buffer_declaration += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n constructor_code += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n continue\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"OutputAllocation\\\")\\n impl = functionality[0].create(buffer)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\"\\\\n\\\\n\\\"\\n constructor_code += \\\"\\\\n\\\\n\\\"\\n\\n #constructor_code += \\\"}\\\\n\\\"\\n\\n self.buffer_declaration = buffer_declaration\\n self.constructor_code = constructor_code\",\n \"def create_training_matrices(experiment, sample_times):\\n # Labels:\\n location_labels = read_location_labels(experiment)\\n locations = get_location_of_persons_at_samples(location_labels, sample_times, experiment)\\n\\n p1_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P1\\\")\\n p2_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P2\\\")\\n p3_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P3\\\")\\n p4_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P4\\\")\\n\\n print(p1_scene_features.loc[0]['predictions'].shape[0])\\n print(len(p1_scene_features['predictions'][0]))\\n data = {\\n \\\"P1\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P2\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P3\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P4\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0]))\\n }\\n\\n for index, loc_label in enumerate(locations):\\n t = loc_label[0]\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P1_eyetracker\\\")\\n p1 = np.mean(p1_scene_features[p1_scene_features['timestamp'].between(t_et - sample_step/2, t_et + sample_step/2)]['predictions'].as_matrix(), axis=0)\\n\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P2_eyetracker\\\")\\n p2 = np.mean(\\n p2_scene_features[p2_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P3_eyetracker\\\")\\n p3 = np.mean(\\n p3_scene_features[p3_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P4_eyetracker\\\")\\n p4 = np.mean(\\n p4_scene_features[p4_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n data[\\\"P1\\\"][index, 0] = t\\n data[\\\"P1\\\"][index, 1:-1] = p1\\n data[\\\"P1\\\"][index, -1] = loc_label[1]\\n\\n data[\\\"P2\\\"][index, 0] = t\\n data[\\\"P2\\\"][index, 1:-1] = p2\\n data[\\\"P2\\\"][index, -1] = loc_label[2]\\n\\n data[\\\"P3\\\"][index, 0] = t\\n data[\\\"P3\\\"][index, 1:-1] = p3\\n data[\\\"P3\\\"][index, -1] = loc_label[3]\\n\\n data[\\\"P4\\\"][index, 0] = t\\n data[\\\"P4\\\"][index, 1:-1] = p4\\n data[\\\"P4\\\"][index, -1] = loc_label[4]\\n\\n return data\",\n \"def initParams(self):\\n sizes = [self.inputDim]+self.layerSizes+[self.outputDim]\\n scales = [np.sqrt(6)/np.sqrt(n+m) for n,m in zip(sizes[:-1],sizes[1:])]\\n self.stack = [[np.random.rand(m,n)*2*s-s,np.zeros((m,1))] \\\\\\n for n,m,s in zip(sizes[:-1],sizes[1:],scales)]\\n self.hActs_M = [cm.empty((s,self.maxBatch)) for s in sizes]\\n\\n if self.train:\\n # Now assuming that all layers are the same size\\n self.grad = [[cm.empty(w.shape),cm.empty(b.shape)] for w,b in self.stack]\\n self.deltasC_M = cm.empty((self.outputDim,self.maxBatch))\\n self.deltasOut_M = cm.empty((sizes[1],self.maxBatch)) \\n self.deltasIn_M = cm.empty((sizes[1],self.maxBatch)) \\n self.tmpGrad_M = cm.empty((self.layerSize,self.maxBatch))\\n \\n # Allocate memory once here and reuse\\n # Store probs\\n self.probs_M = cm.empty((self.outputDim,self.maxBatch))\\n # Store col max\\n self.rowVec_M = cm.empty((1,self.maxBatch))\\n \\n self.stack = [[cm.CUDAMatrix(w),cm.CUDAMatrix(b)]\\n for w,b in self.stack]\\n\\n if self.temporalLayer > 0:\\n # dummy bias used for temporal layer\\n dummy = cm.empty((1,1))\\n dummy.assign(0.0)\\n\\n scale = np.sqrt(6)/np.sqrt(self.layerSize*2)\\n wtf = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\\n self.layerSize)-scale)\\n wtb = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\\n self.layerSize)-scale)\\n self.stack.append([wtf,dummy])\\n self.stack.append([wtb,dummy])\\n\\n # forward and backward activations for temporal layer\\n self.hActsFor_M = cm.empty((self.layerSize,self.maxBatch))\\n self.hActsBack_M = cm.empty((self.layerSize,self.maxBatch))\\n\\n if self.train:\\n dwtf = cm.empty(wtf.shape)\\n self.grad.append([dwtf,dummy])\\n dwtb = cm.empty(wtb.shape)\\n self.grad.append([dwtb,dummy])\\n\\n self.tmpGradBack_M = cm.empty((self.layerSize,self.maxBatch))\\n self.deltasFor_M = cm.empty((self.layerSize,self.maxBatch))\\n self.deltasBack_M = cm.empty((self.layerSize,self.maxBatch))\",\n \"def build(self):\\n self.build_inputs()\\n self.build_image_embeddings()\\n self.build_seq_embeddings()\\n self.build_encoder()\\n self.build_prediction_model()\\n self.setup_encoder_initializer()\\n self.setup_global_step()\\n self.list_trainable_variables()\",\n \"def compile(self):\\n for layer in self.layers:\\n layer._Dense__load()\",\n \"def build(self):\\n self.build_inputs()\\n self.image_embeddings = self.build_image_embeddings(self.images)\\n self.seq_embeddings = self.build_seq_embeddings(self.input_seqs)\\n self.build_model()\\n self.setup_inception_initializer()\\n self.setup_global_step()\",\n \"def newMatrix(self):\\n self.matrix = makeMatrix()\\n for row in range(self.matrix.getHeight()):\\n for column in range(self.matrix.getWidth()):\\n self.canvasGrid[row][column].draw(self.matrix[row][column])\",\n \"def make_matrix():\\n\\n # this imports category, category, data, text, pptx_data\\n\\n if use_test_data:\\n # make a test matrix using create_test_matrix\\n m = matrixfuncs.create_test_matrix()\\n\\n else:\\n # make a matrix by connecting to Slides! and connecting to a data\\n # table.\\n import transformations.utils.slidesconf as slidesconf\\n from Forgetdata.Matrix import ConnectionDefinition\\n conn = ConnectionDefinition()\\n conn.ConnectionString = mtd_filepath # set at top of file\\n conn.Name = \\\"Test\\\"\\n conn.Provider = \\\"SPSS MTD File\\\"\\n liveConnection = slidesconf.connect(conn.ConnectionString,\\n name=conn.Name,\\n provider_name=conn.Provider)\\n\\n m = liveConnection[table_selected]\\n\\n x = tr.MatrixManipulator(m)\\n matrixfuncs.printMatrix(m)\\n\\n for c in m[0]:\\n c.TopMember.Label = c.TopMember.Label.encode('ascii', 'ignore')\\n\\n return m, x\",\n \"def generate_mxp_graph(model_name, activations, stats, first_node_name, last_node_name, io_info,\\n input_type, ignore_strides=False, inline_depthwise=False, verbose=False):\\n network = {}\\n network['layers'] = []\\n network['test_input'] = None\\n network['test_output'] = None\\n network['scale'] = 1.0\\n\\n model = onnx.load(model_name)\\n nodes = model.graph.node\\n inits = model.graph.initializer\\n\\n idx = get_node_index(nodes, first_node_name)\\n if idx == None:\\n if verbose:\\n print('{} does not exist\\\\nopen {} in Netron + check spelling'.format(first_node_name, mname))\\n assert(idx != None)\\n\\n last_idx = get_node_index(nodes, last_node_name)\\n if last_idx == None:\\n if verbose:\\n print('{} does not exist\\\\nopen {} in Netron + check spelling'.format(last_node_name, mname))\\n assert(last_idx != None)\\n\\n while True:\\n node = nodes[idx]\\n if verbose:\\n print(node.name, node.op_type)\\n src_node = get_node_source(nodes, node.input[0])\\n if src_node == None:\\n input_id = node.input[0]\\n else:\\n input_id = src_node.output[0]\\n output_id = node.output[0]\\n\\n\\n if len(network['layers']) == 0:\\n previous = None\\n else:\\n previous = network['layers'][-1]\\n for layer in network['layers']:\\n if layer['output_id'] == input_id:\\n previous = layer\\n\\n input_shapes, output_shapes = get_shapes(activations, stats, node)\\n assert len(output_shapes) == 1, \\\"Multi-output nodes not supported\\\"\\n output_shape = output_shapes[0]\\n if node.op_type == \\\"Conv\\\":\\n c, m, n = input_shapes[0]\\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\\n assert(get_attr(node, 'pads') == None or not any(get_attr(node, 'pads')))\\n\\n group = get_attr(node, 'group')\\n strides = np.asarray(get_attr(node, 'strides')).tolist()\\n dilations = np.asarray(get_attr(node, 'dilations')).tolist()\\n if not group:\\n group = 1\\n if not strides:\\n strides = [1, 1]\\n if not dilations:\\n dilations = [1, 1]\\n\\n use_strided = 0\\n assert(strides == [1, 1] or strides == [2, 2] or strides == [4, 4])\\n\\n if DO_STRIDES and not ignore_strides:\\n if (strides[0] > 1 or strides[1] > 1) and group == 1: # TODO handle depthwise as well\\n assert(previous['output_size'] == int(np.prod(input_shapes[0])))\\n use_strided = 1\\n previous['output_strides'] = strides\\n if verbose:\\n print('adding output strides to previous node')\\n\\n m = m + (m % strides[0])\\n n = n + (n % strides[1])\\n if int(np.prod(input_shapes[0])) != int(c*m*n):\\n if verbose:\\n print('adjusting size for strided maps')\\n previous['output_size'] = int(c*4*m//strides[0]*n//strides[1])\\n previous['output_shape'] = (c*4,m//strides[0],n//strides[1])\\n\\n w = get_tensor(inits, node.input[1])\\n kernels, channels, _, _ = w.shape\\n if len(node.input) == 3:\\n b = get_tensor(inits, node.input[2])\\n\\n conv_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(c*m*n),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels * group,\\n 'kernels': kernels,\\n 'kernel_shape': kernel_shape,\\n 'dilations': dilations,\\n 'strides': strides,\\n 'group': group,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n 'use_cvi': 0,\\n 'use_depthwise': 0,\\n 'use_strided': use_strided,\\n \\\"biases\\\": [],\\n \\\"weights\\\": [],\\n \\\"sublayers\\\": [],\\n }\\n\\n w = w.flatten().tolist()\\n conv_layer['weights'] = base64.b64encode(struct.pack(\\\"f\\\"*len(w), *w)).decode()\\n\\n if len(node.input) == 3:\\n b = b.flatten().tolist()\\n else:\\n b = [0 for _ in range(kernels)]\\n conv_layer['biases'] = base64.b64encode(struct.pack(\\\"f\\\"*len(b), *b)).decode()\\n\\n network['layers'].append(conv_layer)\\n\\n elif node.op_type == \\\"Gemm\\\":\\n w = get_tensor(inits, node.input[1])\\n output_size, input_size = w.shape\\n\\n if len(node.input) == 3:\\n b = get_tensor(inits, node.input[2])\\n\\n gemm_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(np.prod(input_shapes[0])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape': output_shape,\\n 'gemm_input_size': input_size,\\n 'gemm_output_size': output_size,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"biases\\\": [],\\n \\\"weights\\\": [],\\n \\\"sublayers\\\": [],\\n }\\n\\n w = w.flatten().tolist()\\n gemm_layer['weights'] = base64.b64encode(struct.pack(\\\"f\\\"*len(w), *w)).decode()\\n\\n if len(node.input) == 3:\\n b = b.flatten().tolist()\\n else:\\n b = [0 for _ in range(output_size)]\\n gemm_layer['biases'] = base64.b64encode(struct.pack(\\\"f\\\"*len(b), *b)).decode()\\n network['layers'].append(gemm_layer)\\n\\n elif node.op_type in multipath_nodes:\\n node_inputs = get_previous_nodes(nodes, node)\\n shapes = input_shapes\\n\\n if node.op_type == \\\"Sum\\\":\\n assert(all([x == shapes[0] for x in shapes[1:]]))\\n elif node.op_type == \\\"Concat\\\":\\n assert(all([x[1:] == shapes[0][1:] for x in shapes[1:]]))\\n\\n buf = node_inputs[0].name\\n if node.op_type == \\\"Concat\\\":\\n buf = output_id\\n\\n buffer_offset = 0\\n for n, node_input in enumerate(node_inputs):\\n noutput = node_input.output[0]\\n for l, layer in enumerate(network['layers']):\\n if layer['output_id'] == noutput: # if layer pointing to this node\\n network['layers'][l]['output_id'] = buf # rename layer's output\\n network['layers'][l]['buffer_offset'] = buffer_offset # and offset appropriately\\n if layer['input_id'] == noutput:\\n network['layers'][l]['input_id'] = buf #TODO\\n\\n buffer_offset += int(np.prod(input_shapes[n]))\\n\\n if node.op_type == \\\"Sum\\\":\\n channels, m, n = shape3d(output_shape)\\n sum_layer = {\\n 'op_type': \\\"Sum\\\",\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': node_inputs[0].name,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n 'num_inputs': len(node.input),\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(sum_layer)\\n\\n elif node.op_type == \\\"Identity\\\":\\n shapes = input_shapes\\n\\n channels, m, n = shape3d(output_shape)\\n identity_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(identity_layer)\\n\\n elif node.op_type == \\\"LRN\\\":\\n shapes = input_shapes\\n channels, m, n = shape3d(output_shape)\\n lrn_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'alpha': get_attr(node, 'alpha'),\\n 'beta': get_attr(node, 'beta'),\\n 'bias': get_attr(node, 'bias'),\\n 'size': get_attr(node, 'size'),\\n 'scale': 1.0,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(lrn_layer)\\n\\n elif node.op_type == \\\"Scale\\\":\\n scale_sublayer = {\\n 'op_type': 'Scale',\\n 'name': node.name,\\n \\\"use_replay\\\": 1,\\n 'scale': get_attr(node, 'scale'),\\n }\\n previous['sublayers'].append(scale_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type in [\\\"GlobalAveragePool\\\", \\\"GlobalMaxPool\\\"]:\\n assert(previous['n'] == previous['m'])\\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\\n strides = np.asarray(get_attr(node, 'strides')).tolist()\\n pads = pads6(node)\\n pool_sublayer = {\\n 'op_type': node.op_type.replace('Global', ''),\\n 'name': node.name,\\n 'use_replay': 0,\\n 'kernel_shape': [previous['m'], previous['n']],\\n 'strides': [previous['m'], previous['n']],\\n 'pads': pads,\\n }\\n previous['sublayers'].append(pool_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n previous['output_shape'] = (output_shape)\\n\\n elif node.op_type in [\\\"MaxPool\\\", \\\"AveragePool\\\"]:\\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\\n\\n if node.op_type == \\\"AveragePool\\\": #TODO quick fix for tf average pool quirk\\n if kernel_shape[0] * kernel_shape[1] == previous['m'] * previous['n']:\\n kernel_shape = [previous['m'], previous['n']]\\n strides = np.asarray(get_attr(node, 'strides')).tolist()\\n if strides is None:\\n strides = [ 1 for _ in kernel_shape]\\n pads = pads6(node)\\n pool_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'kernel_shape': kernel_shape,\\n 'strides': strides,\\n 'pads': pads,\\n }\\n previous['sublayers'].append(pool_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n previous['output_shape'] = (output_shape)\\n elif node.op_type == \\\"PRelu\\\":\\n slope = get_tensor(inits, node.input[1])\\n slope = slope.flatten().tolist()\\n prelu_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'slope': slope,\\n }\\n previous['sublayers'].append(prelu_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"LeakyRelu\\\":\\n alpha = get_attr(node, 'alpha')\\n if alpha is None:\\n alpha = .01\\n leaky_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'alpha': alpha\\n }\\n previous['sublayers'].append(leaky_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"Relu\\\":\\n relu_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n }\\n previous['sublayers'].append(relu_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"Clip\\\":\\n clip_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'min': float(get_tensor(inits,node.input[1])),\\n 'max': float(get_tensor(inits,node.input[2])),\\n }\\n previous['sublayers'].append(clip_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"Pad\\\":\\n pads = pads6(get_tensor(inits,node.input[1]).tolist())\\n value = int(get_tensor(inits,node.input[2]))\\n if value < -1:\\n value = -1\\n if value > 1:\\n value = 1\\n pad_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'value': value,\\n 'pads': pads,\\n }\\n previous['sublayers'].append(pad_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n previous['output_shape'] = (output_shape)\\n elif node.op_type in [\\\"Add\\\", \\\"Mul\\\", \\\"Sub\\\", \\\"Div\\\"]:\\n\\n skip = False\\n if node.op_type == \\\"Mul\\\":\\n next_nodes = get_node_inputs(nodes, node.output[0])\\n if node.name == nodes[-1].name:\\n if verbose:\\n print('removing final scale node')\\n skip = True\\n\\n elif previous['op_type'] in [\\\"LRN\\\"]:\\n if verbose:\\n print('skipping mul after lrn')\\n array = get_tensor(inits, node.input[1])\\n if array is None:\\n array = get_tensor(inits, node.input[0])\\n previous['scale'] = float(array[0])\\n print('skipping mul after lrn', previous['scale'], previous['input_id'], previous['output_id'])\\n\\n skip = True\\n\\n elif next_nodes[0].op_type in [\\\"Softmax\\\"]:\\n if verbose:\\n print('skipping mul before softmax')\\n skip = True\\n\\n array = get_tensor(inits, node.input[1])\\n if array is None:\\n array = get_tensor(inits, node.input[0])\\n c = activations[node.input[1]].shape[1]\\n else:\\n c = input_shapes[0][0]\\n\\n if node.op_type == \\\"Add\\\": # TODO for scalar Add\\n dims = len(np.squeeze(array).shape)\\n if dims == 0:\\n array = np.ones((c, 1)) * array\\n\\n dims = len(np.squeeze(array).shape)\\n if c == 1 and dims == 0:\\n dims = 1\\n\\n array = array.flatten().tolist()\\n # force_broadcast_2 = False\\n # if force_broadcast_2:\\n # # if c != 1 and dims == 0:\\n # if c != 1 and dims == 0 and node.op_type != \\\"Mul\\\": # TODO forcing to broadcast 2 not broadcast 3\\n # dims = 1\\n # array = [array[0] for _ in range(c)]\\n\\n if not skip:\\n arithmetic_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'dims': dims,\\n 'array': array,\\n }\\n previous['sublayers'].append(arithmetic_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type in [\\\"Abs\\\", \\\"Max\\\", \\\"Mean\\\", \\\"Min\\\", \\\"Neg\\\", \\\"Not\\\"]:\\n unary_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n }\\n previous['sublayers'].append(unary_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n\\n elif node.op_type == \\\"Reshape\\\":\\n dims = get_tensor(inits, node.input[1])\\n\\n if len(dims) == 4 and dims[-1] == 2:\\n idx += 6\\n node = nodes[idx]\\n output_id = node.output[0]\\n _, output_shapes = get_shapes(activations, stats, node)\\n output_shape = output_shapes[0]\\n channels, m, n = shape3d(output_shape)\\n reorg_layer = {\\n 'op_type': \\\"Reorg\\\",\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape': output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n \\\"stride\\\": int(dims[-1]),\\n }\\n network['layers'].append(reorg_layer)\\n else:\\n previous['output_id'] = output_id\\n\\n elif node.op_type in [\\\"Flatten\\\",'Cast']:\\n previous['output_id'] = output_id\\n elif node.op_type == \\\"Resize\\\":\\n scales = get_tensor(inits, node.input[2])\\n assert(scales[0] == 1 and scales[1] == 1)\\n scale = float(scales[2])\\n mode = get_attr(node, 'mode').decode()\\n assert(mode == 'nearest' or mode == 'linear')\\n shapes = input_shapes[:1]\\n channels, m, n = shape3d(output_shape)\\n in_size= [d for d in one_elem(input_shapes)[1:]]\\n replay = 0 if in_size == [1,1] else 1\\n resize_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': replay,\\n 'input_size': int(np.prod(one_elem(input_shapes))),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'mode' :mode,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n 'scale': [float(scales[2]),float(scales[3])],\\n }\\n network['layers'].append(resize_layer)\\n elif node.op_type == \\\"ArgMax\\\":\\n input_shape = one_elem(input_shapes)\\n channels, m, n = shape3d(input_shape)\\n argmax_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n 'scale': [float(scales[2]),float(scales[3])],\\n }\\n network['layers'].append(argmax_layer)\\n\\n elif node.op_type == \\\"Softmax\\\":\\n prev = get_previous_nodes(nodes, node)[0]\\n if prev.op_type == \\\"Mul\\\":\\n scale = get_tensor(inits, prev.input[1])\\n scale = scale.flatten().tolist()\\n else:\\n scale = [1.0]\\n if len(scale) > 1:\\n raise NotImplementedError(\\\"Broadcast scale not implemented for softmax\\\")\\n\\n shapes = input_shapes\\n channels, m, n = shape3d(output_shape)\\n softmax_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n 'scale': scale,\\n 'size': len(scale),\\n }\\n network['layers'].append(softmax_layer)\\n\\n # softmax_sublayer = {u'op_type': u'Softmax', 'scale': 1.0}\\n # previous['sublayers'].append(softmax_sublayer)\\n # previous['output_id'] = output_id\\n # print('warning SOFTMAX ignored!... fine if last layer and sorting outputs')\\n\\n elif node.op_type == \\\"Transpose\\\":\\n shapes = input_shapes\\n\\n channels, m, n = shape3d(output_shape)\\n permutation =[p-1 for p in get_attr(node, 'perm')[1:]]\\n transpose_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n 'permutation':permutation,\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(transpose_layer)\\n else:\\n raise RuntimeError('Unknown node type:{} '.format(node.op_type))\\n\\n idx += 1\\n if idx > last_idx:\\n break\\n\\n unsigned_network_inputs = input_type == np.uint8\\n\\n if CVI_1x1:\\n network = mxp_gemm_to_conv(network)\\n\\n network = mxp_set_replay(network, io_info)\\n network = mxp_set_cvi(network)\\n network = mxp_set_unsigned(network, unsigned_network_inputs)\\n\\n if inline_depthwise:\\n network = mxp_inline_depthwise(network)\\n\\n network = mxp_describe_layers(network)\\n network = mxp_number_buffers(network)\\n buffers = mxp_size_buffers(network)\\n network = mxp_number_sublayers(network)\\n\\n network['num_layers'] = len(network['layers'])\\n network['buffers'] = buffers\\n\\n return network\",\n \"def generate(self):\\n self.generate_points()\\n self.generate_edges()\",\n \"def create_matrix(self):\\n import random\\n random.seed()\\n #pecas_disponiveis = [\\\"escudo\\\", \\\"espada\\\", \\\"espada_dupla\\\", \\\"machadinha\\\", \\\"adaga\\\", \\\"punhais\\\"]\\n pecas_disponiveis = [\\\"escudo\\\", \\\"punhais\\\", \\\"espada_dupla\\\", \\\"machadinha\\\", \\\"adaga\\\"]\\n x_start, y_start = 10, self.running.top_bar\\n x, y = x_start, y_start\\n anterior_esq = [None] * self.running.linhas\\n anterior_acima = None\\n\\n for i in range(self.running.colunas):\\n coluna = []\\n for j in range(self.running.linhas):\\n possiveis_escolhas = pecas_disponiveis.copy()\\n if possiveis_escolhas.count(anterior_esq[j]) > 0: possiveis_escolhas.remove(anterior_esq[j])\\n if possiveis_escolhas.count(anterior_acima) > 0 : possiveis_escolhas.remove(anterior_acima)\\n \\n e_type = random.choice(possiveis_escolhas)\\n tile = Tile(self.game, x, y, e_type)\\n coluna.append(tile)\\n self.running.game_images.append(tile.game_image)\\n y += self.running.y_space\\n anterior_esq[j] = e_type\\n anterior_acima = e_type\\n self.running.tabuleiro.append(coluna)\\n x += self.running.x_space\\n y = y_start\\n return\",\n \"def create_dev_matrix(self):\\n if os.path.exists(self.dev_matrix_h5_path):\\n print(\\\"[LOGGING]: \\\" + self.dev_matrix_h5_path + \\\" exists!\\\")\\n return\\n\\n with h5py.File(self.dev_matrix_h5_path, 'w') as f:\\n\\n for mode in ['train', 'test']:\\n for device in ['a', 'b', 'c']:\\n grp = f.create_group(mode + '/' + device)\\n grp['data'], grp['label'] = self.extract_npy(mode=mode, devices=device)\\n # add parallel data as separate device p\\n grp = f.create_group(mode + '/p')\\n grp['data'], grp['label'] = self.extrac_para_npy(mode=mode)\\n\\n # add neg parallel data as device A\\n grp = f.create_group(mode + '/A')\\n grp['data'], grp['label'] = self.extract_neg_para_npy(mode=mode)\\n f.close()\",\n \"def _generate_adjacency_matrices(self):\\n self.adj_matrices = dict()\\n mes = []\\n args = []\\n for metaedge in self.metaedges:\\n mes.append(metaedge)\\n args.append(self._prepare_parallel_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\\n front_num=0)\\n for metaedge, matrix in zip(mes, res):\\n self.adj_matrices[metaedge] = matrix\",\n \"def output_rule_feature_matrices():\\n with open(config.data_path + config.sentiment_seed, 'rb') as input_file:\\n sentiment_dict = pickle.load(input_file)\\n seed_sentiments = set(sentiment_dict.keys())\\n \\n for i in range(len(config.file_names)):\\n if i is 5:\\n print('processing ', config.file_names[i])\\n fname = config.file_names[i]\\n feature_x, feature_y, opinion_x, opinion_y = text_to_matrix(\\n fname, seed_sentiments)\\n feature_x = np.transpose(feature_x)\\n opinion_x = np.transpose(opinion_x)\\n with open('../results/' + fname + '_rule_feature_matrix.pickle', 'wb') as f:\\n pickle.dump(feature_x, f)\\n with open('../results/' + fname + '_rule_opinion_matrix.pickle', 'wb') as f:\\n pickle.dump(opinion_x, f)\\n\\n with open('../results/' + fname + '_feature_label.pickle', 'wb') as f:\\n pickle.dump(feature_y.ravel(), f)\\n with open('../results/' + fname + '_opinion_label.pickle', 'wb') as f:\\n pickle.dump(opinion_y.ravel(), f)\",\n \"def get_linear_discrete_matrices(self):\\n\\n vf_op, vb_op = get_operating_point_inputs(self.operating_point[1], self.model_type)\\n if self.model_type == ModelType.EASY:\\n At, Bt, Vf_op, Vd_op = getLinearizedMatrices(self.model_type, self.operating_point[0:6], vf_op, vb_op)\\n elif self.model_type == ModelType.GYROMOMENT:\\n At, Bt = get_gyro_matrices(self.operating_point, self.operating_point[6] / mc.K_f, vf_op, vb_op)\\n if self.model_type == ModelType.EASY:\\n Ct = np.array([[1, 0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0, 0]])\\n Dt = np.array([[0, 0],\\n [0, 0],\\n [0, 0]])\\n elif self.model_type == ModelType.GYROMOMENT:\\n if self.nOutputs == 3:\\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0, 0, 0, 0]])\\n Dt = np.array([[0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0]])\\n elif self.nOutputs == 5:\\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 1, 0],\\n [0, 0, 0, 0, 0, 0, 0, 1]])\\n Dt = np.array([[0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0]])\\n\\n Ak, Bk, Ck, Dk = discretize_linear_state_space(At, Bt, Ct, Dt, self.timeStep)\\n return Ak, Bk, Ck, Dk\",\n \"def make_input_materials(self) :\\n # 1 5 1 MATERIAL 1 (arbitrary line, i think) \\n # 1.4493e+00 9.9000e-03 7.9000e-03 1. 0. 0. 7.9000e-03 1.\\n # 3.8070e-01 1.0420e-01 1.6920e-01 0 1.5100e-02 0. 1.6920e-01 1.\\n self.input_materials = \\\"\\\"\\n number_mats = len(self.core.pattern)+1\\n a = self.core.assemblies\\n for i in range(0, number_mats-1) :\\n # Row 1: description.\\n self.input_materials += \\\" \\\" + str(i+1) + \\\" 5 1 MATERIAL \\\" + \\\\\\n str(i+1) + \\\" (\\\" + \\\\\\n a[i].model + \\\", \\\" + \\\\\\n str(a[i].enrichment) + \\\" w/o, \\\" + \\\\\\n str(a[i].burnup) + \\\" MWd/kg)\\\\n\\\" \\n # Rows 2 and 3.\\n D1,D2,A1,A2,F1,F2,S12 = a[i].get_constants()\\n d = np.array([[D1,A1,F1,1.0,0.0,0.0,F1,1.0],[D2,A2,F2,0.0,S12,0.0,F2,1.0]])\\n for j in range(0, 2) :\\n for k in range(0, 8) :\\n self.input_materials +='%12.4e' %(d[j,k])\\n self.input_materials += '\\\\n'\\n \\n a = self.core.reflector\\n # Row 1: description.\\n self.input_materials += \\\" \\\" + str(number_mats) + \\\" 5 1 MATERIAL \\\" + \\\\\\n str(number_mats) + \\\" (REFLECTOR) \\\\n\\\" \\n # Rows 2 and 3.\\n D1,D2,A1,A2,F1,F2,S12 = a.get_constants()\\n d = np.array([[D1,A1,F1,1.0,0.0,0.0,F1,1.0],[D2,A2,F2,0.0,S12,0.0,F2,1.0]])\\n for i in range(0, 2) :\\n for j in range(0, 8) :\\n self.input_materials +='%12.4e' %(d[i,j])\\n self.input_materials += '\\\\n'\\n self.input_materials += \\\"WHITE\\\\n\\\" + \\\"BLACK\\\\n\\\" + \\\"END\\\\n\\\"\",\n \"def create_weight_matrices(self):\\n rad = 1 / np.sqrt(self.no_of_in_nodes)\\n X = truncated_normal(mean=0, \\n sd=1, \\n low=-rad, \\n upp=rad)\\n self.wih = X.rvs((self.no_of_hidden_nodes, \\n self.no_of_in_nodes))\\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\\n self.who = X.rvs((self.no_of_out_nodes, \\n self.no_of_hidden_nodes))\",\n \"def _calc_matrix(self):\\n\\t\\tz = self.zoom\\n\\t\\talloc = self.allocation\\n\\t\\tif self.image:\\n\\t\\t\\tiw, ih = self.image.get_width(), self.image.get_height()\\n\\t\\telse:\\n\\t\\t\\tiw, ih = 0, 0\\n#\\t\\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\\n\\t\\t\\n\\t\\ti2w = cairo.Matrix(\\n\\t\\t\\tz,0,\\n\\t\\t\\t0,z,\\n\\t\\t\\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \\n\\t\\t\\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\\n\\t\\t\\t)\\n\\t\\t\\n\\t\\tself._i2w_matrix = i2w\\n\\t\\t\\n\\t\\tw2i = cairo.Matrix(*i2w) #copy\\n\\t\\tw2i.invert()\\n\\t\\tself._w2i_matrix = w2i\",\n \"def _build_model(self):\\n\\n with tf.variable_scope(\\\"Matchnet\\\", reuse=tf.AUTO_REUSE):\\n # For determining the runtime shape\\n x_shp = tf.shape(self.x_in)\\n\\n # -------------------- Network archintecture --------------------\\n # Build graph\\n print(\\\"Building Graph\\\")\\n self.logits = build_graph(self.x_in, self.is_training, self.config)\\n # ---------------------------------------------------------------\\n\\n # Turn into weights for each sample\\n weights = tf.nn.relu(tf.tanh(self.logits))\\n\\n # Make input data (num_img_pair x num_corr x 4)\\n xx = tf.transpose(tf.reshape(\\n self.x_in, (x_shp[0], x_shp[2], 4)), (0, 2, 1))\\n\\n # Create the matrix to be used for the eight-point algorithm\\n X = tf.transpose(tf.stack([\\n xx[:, 2] * xx[:, 0], xx[:, 2] * xx[:, 1], xx[:, 2],\\n xx[:, 3] * xx[:, 0], xx[:, 3] * xx[:, 1], xx[:, 3],\\n xx[:, 0], xx[:, 1], tf.ones_like(xx[:, 0])\\n ], axis=1), (0, 2, 1))\\n print(\\\"X shape = {}\\\".format(X.shape))\\n wX = tf.reshape(weights, (x_shp[0], x_shp[2], 1)) * X\\n print(\\\"wX shape = {}\\\".format(wX.shape))\\n XwX = tf.matmul(tf.transpose(X, (0, 2, 1)), wX)\\n print(\\\"XwX shape = {}\\\".format(XwX.shape))\\n\\n # Recover essential matrix from self-adjoing eigen\\n e, v = tf.self_adjoint_eig(XwX)\\n self.e_hat = tf.reshape(v[:, :, 0], (x_shp[0], 9))\\n # Make unit norm just in case\\n self.e_hat /= tf.norm(self.e_hat, axis=1, keep_dims=True)\",\n \"def build_augmented_matrix(self):\\r\\n for row in range(self.SIZE):\\r\\n self.matrix[row].append(self.result[row])\",\n \"def generate(self):\\n self.training_data.gen_x(self.x_func)\\n self.training_data.gen_a(self.a_func)\\n self.training_data.gen_y(self.y_func)\\n \\n self.testing_data.gen_x(self.x_func)\\n self.testing_data.gen_ys(self.y_func)\\n self.testing_data.gen_azero(self.ytotal_func)\",\n \"def build_modules(self):\\n self.backbone = Backbone(\\n self.configs['backbone'],\\n freeze_backbone=self.configs['freeze_backbone'],\\n freeze_batchnorm=True\\n )\\n\\n backbone_channel_sizes = get_backbone_channel_sizes(self.backbone)\\n\\n self.fpn = FeaturePyramidNetwork(\\n backbone_channel_sizes=backbone_channel_sizes,\\n min_feature_level=self.configs['min_feature_level'],\\n max_feature_level=self.configs['max_feature_level'],\\n feature_size=self.configs['pyramid_feature_size']\\n )\\n\\n self.shared_conv_model = SharedConvModel(\\n input_feature_size=self.configs['pyramid_feature_size'],\\n feature_size=self.configs['shared_conv_feature_size'],\\n num_layers=self.configs['shared_conv_num_layers']\\n )\\n\\n if self.configs['shared_conv_num_layers'] > 0:\\n shared_conv_output_size = self.configs['shared_conv_feature_size']\\n else:\\n shared_conv_output_size = self.configs['pyramid_feature_size']\\n\\n self.ofn = ObjectFinderNetwork(\\n input_feature_size=shared_conv_output_size,\\n feature_size=self.configs['finder_feature_size'],\\n num_layers=self.configs['finder_num_layers']\\n )\\n\\n self.ofn_loss_fn\\n\\n # self.classification_model = ClassificationModel()\\n #\\n # self.regression_model = RegressionModel()\",\n \"def build(node):\\n yield Matrix(node[Matrix.TAG])\",\n \"def createMatrices(file, word2Idx, maxSentenceLen, extendMapping, labelsMapping, aspectMapping, typeMapping, tenseMapping, eventClassMapping, distanceMapping, sentenceLengthMapping):\\n labels = []\\n eventMatrix = []\\n timeMatrix = []\\n\\n sentenceLengths = []\\n sentenceMatrix = []\\n positionMatrix_e = []\\n positionMatrix_t = []\\n\\n aspectMatrix = []\\n typeMatrix = []\\n tenseMatrix = []\\n eventClassMatrix = []\\n featuresList = []\\n \\n \\n minDistance = 0\\n for distanceKey in distanceMapping.iterkeys():\\n if isinstance(distanceKey, (int, long)):\\n minDistance = min(minDistance, int(distanceKey))\\n \\n for line in open(file):\\n features = eval(line.strip())\\n featuresList.append(features)\\n label = features['label']\\n event = features[\\\"Token[0]\\\"]\\n eventPosition = int(features[\\\"eventPosition\\\"])\\n tokens = features[\\\"textInBetween\\\"] if \\\"textInBetween\\\" in features else features[\\\"sentence\\\"]\\n \\n aspect = features[\\\"aspect\\\"]\\n tense = features[\\\"tense\\\"]\\n eventClass = features[\\\"eventClass\\\"]\\n \\n labels.append(labelsMapping[label.lower()] if label.lower() in labelsMapping else -1)\\n eventMatrix.append(getWordIdx(event, word2Idx))\\n \\n aspectMatrix.append(getMappingIdx(aspect, aspectMapping, extendMapping))\\n tenseMatrix.append(getMappingIdx(tense, tenseMapping, extendMapping))\\n eventClassMatrix.append(getMappingIdx(eventClass, eventClassMapping, extendMapping))\\n \\n if 'TimeTokenFirst' in features:\\n time = features['TimeTokenFirst']\\n timeMatrix.append(getWordIdx(time, word2Idx))\\n \\n if 'type' in features:\\n type = features[\\\"type\\\"]\\n typeMatrix.append(getMappingIdx(type, typeMapping, extendMapping))\\n \\n timePosition = int(features[\\\"timeFirstPosition\\\"]) if 'timeFirstPosition' in features else 0\\n \\n\\n if len(tokens) in sentenceLengthMapping:\\n sentenceLengths.append(sentenceLengthMapping[len(tokens)])\\n else:\\n sentenceLengths.append(sentenceLengthMapping['GreaterMax'])\\n\\n \\n tokenIds = np.zeros(maxSentenceLen)\\n positionValues_e = np.zeros(maxSentenceLen)\\n positionValues_t = np.zeros(maxSentenceLen)\\n for idx in xrange(0, min(maxSentenceLen, len(tokens))):\\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\\n \\n distance_e = idx - eventPosition\\n distance_t = idx - timePosition\\n\\n if distance_e in distanceMapping:\\n positionValues_e[idx] = distanceMapping[distance_e]\\n elif distance_e <= minDistance:\\n positionValues_e[idx] = distanceMapping['LowerMin']\\n else:\\n positionValues_e[idx] = distanceMapping['GreaterMax']\\n \\n if distance_t in distanceMapping:\\n positionValues_t[idx] = distanceMapping[distance_t]\\n elif distance_t <= minDistance:\\n positionValues_t[idx] = distanceMapping['LowerMin']\\n else:\\n positionValues_t[idx] = distanceMapping['GreaterMax']\\n\\n sentenceMatrix.append(tokenIds)\\n positionMatrix_e.append(positionValues_e)\\n positionMatrix_t.append(positionValues_t)\\n\\n \\n labels = np.array(labels, dtype='int32')\\n eventMatrix = np.expand_dims(np.array(eventMatrix, dtype='int32'), axis=1)\\n timeMatrix = np.expand_dims(np.array(timeMatrix, dtype='int32'), axis=1)\\n aspectMatrix = np.expand_dims(np.array(aspectMatrix, dtype='int32'), axis=1)\\n typeMatrix = np.expand_dims(np.array(typeMatrix, dtype='int32'), axis=1)\\n tenseMatrix = np.expand_dims(np.array(tenseMatrix, dtype='int32'), axis=1)\\n eventClassMatrix = np.expand_dims(np.array(eventClassMatrix, dtype='int32'), axis=1)\\n sentenceLengths = np.expand_dims(np.array(sentenceLengths, dtype='int32'), axis=1)\\n \\n \\n sentenceMatrix = np.array(sentenceMatrix, dtype='int32')\\n positionMatrix_e = np.array(positionMatrix_e, dtype='int32')\\n positionMatrix_t = np.array(positionMatrix_t, dtype='int32')\\n \\n\\n\\n return {'labels': labels,\\n 'event':eventMatrix, \\n 'time':timeMatrix, \\n 'sentence':sentenceMatrix, \\n 'positions_e':positionMatrix_e, \\n 'positions_t':positionMatrix_t, \\n 'aspect':aspectMatrix, \\n 'tense':tenseMatrix, \\n 'eventClass':eventClassMatrix, \\n 'type': typeMatrix,\\n 'sentence_len': sentenceLengths,\\n 'features': featuresList}\",\n \"def run(self):\\n # load_data\\n layers = self.load_all_data() # list of tuples (file_name, feature_matrix)\\n\\n # check variable types\\n if len(self.method) == 1:\\n self.method = [self.method[0]] * len(layers)\\n elif len(layers) != len(self.method):\\n raise ValueError(\\\"Number of matrices extracted from input files and number of similarity methods \\\" +\\n \\\"does not correspond\\\")\\n\\n # check missing value parameter\\n if len(self.missing) == 1:\\n self.logger.info(\\\"#Setting all 'missing' parameters to {}\\\".format(self.missing[0]))\\n self.missing = [self.missing[0]] * len(layers)\\n elif len(layers) != len(self.missing):\\n raise ValueError(\\\"Number of matrices extracted from input files and number of given missing parameters \\\" +\\n \\\"does not correspond\\\")\\n\\n # extract sample names\\n all_samples = set()\\n for layer_data in layers:\\n all_samples = all_samples.union({name for name in layer_data[1].columns})\\n self.logger.info(\\\"#Total number of unique samples: {}\\\".format(len(all_samples)))\\n\\n out_arrays = {}\\n adj_matrices = []\\n\\n # create adjacency matrices\\n for i in range(len(layers)):\\n self.logger.info(\\\"#Layer: {}\\\".format(i))\\n layer_data = layers[i][1]\\n\\n # add missing samples layer\\n samples = {name for name in layer_data.columns}\\n for name in all_samples - samples:\\n layer_data[name] = np.nan\\n\\n # sort data frame by sample names\\n layer_data.sort_index(axis=1, inplace=True)\\n\\n # extract feature matrices\\n f = layer_data.values.T\\n self.logger.info(\\\"Feature matrix: ({} samples x {} features)\\\".format(f.shape[0], f.shape[1]))\\n\\n # check if feature matrix values are correct\\n ncat = check_categories(f)\\n if ncat != [0, 1]:\\n standardized = is_standardized(f, axis=0, atol=self.atol)\\n if not standardized[0]:\\n raise ValueError(\\\"Incorrect values in feature matrix. Mean of features in \\\" +\\n \\\"({},{}) \\\".format(round(standardized[1][0], 3), round(standardized[1][1], 3)) +\\n \\\"range. Standard deviation of features in \\\" +\\n \\\"({}, {}) \\\".format(round(standardized[2][0], 3), round(standardized[2][1], 3)) +\\n \\\"range. Please, supply either binary dataset \\\" +\\n \\\"(0 or 1 feature values) or continuous values standardized feature-wise. \\\" +\\n \\\"Alternatively for almost standardized continuous data, \\\" +\\n \\\"increase '-atol' parameter value (currently {}).\\\".format(self.atol))\\n else:\\n self.logger.debug(\\\"Data is correctly standardized\\\")\\n else:\\n self.logger.debug(\\\"Found two unique categories in data: [0, 1]\\\")\\n if self.method[i] != 'cosine':\\n self.logger.info(\\\"Using '{}' similarity for [0, 1] data. \\\".format(self.method[i]) +\\n \\\"Suggested better measure: cosine similarity.\\\")\\n\\n # create adjacency matrix\\n a = feature_to_adjacency(f, missing=self.missing[i], method=self.method[i], n=self.k, alpha=self.alpha)\\n self.logger.info('Adjacency matrix {} created [similarity method: {}]'.format(a.shape, self.method[i]))\\n\\n # plot adjacency matrix\\n plot_path = self.plot_base + \\\"_\\\" + str(i) + \\\".png\\\" if self.plot else self.plot_base\\n plot_heatmap_seaborn(a, title=\\\"Layer {} (source:{})\\\".format(i, layers[i][0]), file_path=plot_path)\\n if self.plot:\\n self.logger.info(\\\"Adjacency matrix plot saved to {}\\\".format(plot_path))\\n\\n # add matrices to output arrays\\n out_arrays[str(i)] = a\\n adj_matrices.append(a)\\n out_arrays[\\\"f\\\" + str(i)] = f\\n\\n # check if there are samples not accessible in any layer\\n missing_samples = []\\n for a in adj_matrices:\\n missing_samples += [i for i in range(a.shape[1]) if np.all(np.isnan(a[:, i]))]\\n\\n samples_to_drop = [sample for sample, val in Counter(missing_samples).items() if val == len(adj_matrices)]\\n if samples_to_drop:\\n # drop inaccessible samples\\n self.logger.info(\\\"Found samples inaccessible in every layer of graph. \\\" +\\n \\\"Try changing '-missing' parameter or inspect your data \\\")\\n sample_names = np.array(sorted(list(all_samples)))[np.array(samples_to_drop)]\\n self.logger.info(\\\"Dropped samples: {}\\\".format(list(sample_names)))\\n updated_out_arrays = {}\\n selector = np.array([x for x in range(len(all_samples)) if x not in samples_to_drop])\\n for i in range(len(out_arrays.keys())):\\n if str(i) not in out_arrays.keys():\\n break\\n updated_out_arrays[str(i)] = out_arrays[str(i)][selector[:, None], selector]\\n updated_out_arrays[\\\"f\\\" + str(i)] = out_arrays[\\\"f\\\" + str(i)][selector, :]\\n\\n # create output file\\n updated_out_arrays[\\\"samples\\\"] = np.array(sorted(list(all_samples)))[selector]\\n save_arrays_to_npz(data=updated_out_arrays, file_path=self.outfile)\\n\\n else:\\n # create output file\\n out_arrays[\\\"samples\\\"] = np.array(sorted(list(all_samples)))\\n save_arrays_to_npz(data=out_arrays, file_path=self.outfile)\\n\\n self.logger.info(\\\"#Output file {} created\\\".format(self.outfile))\",\n \"def build_generator2D_(self, model_shape, filters=32, k_size=4, z_size=500, summary=False, model_file=None, name='gan_g_'):\\n if (model_file):\\n \\\"\\\"\\\"\\n Load pretreined model\\n \\\"\\\"\\\"\\n model = self.utils.build_pretrained_model(model_file)\\n if (summary):\\n model.summary()\\n return model\\n else:\\n\\n n_rows = model_shape[0]\\n n_cols = model_shape[1]\\n c_dims = model_shape[2]\\n input_shape = (z_size,)\\n if n_rows % 8 !=0:\\n height = n_rows//8 + 1\\n else:\\n height = n_rows//8\\n if n_cols % 8 !=0:\\n width = n_cols//8 +1\\n else:\\n width = n_cols//8\\n \\n num_init_neurons = 8*filters \\n reshape_size= (height, width, num_init_neurons)\\n \\n # 8*height, 4*height, 2*height, height = n_rows, n_rows//2, n_rows//4, n_rows//8\\n rows_matching = np.equal([2*height, 4*height, 8*height], [n_rows//4, n_rows//2, n_rows])\\n index_rows = np.where(np.logical_not(rows_matching))[0]\\n if len(index_rows) > 0:\\n index_rows = index_rows[0]\\n # print(index_rows)\\n # 8*width, 4*width, 2*width, width = n_cols//1, n_cols//2, n_cols//4, n_cols//8\\n cols_matching = np.equal([2*width, 4*width, 8*width], [n_cols//4, n_cols//2, n_cols])\\n index_cols = np.where(np.logical_not(cols_matching))[0]\\n if len (index_cols) > 0:\\n index_cols = index_cols[0]\\n # print(index_cols)\\n\\n input_layer = Input(shape=input_shape, name=name+'input')\\n g = Dense(width * height * num_init_neurons, kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(input_layer)\\n g = Reshape(reshape_size, name=name+'reshape')(g)\\n g = BatchNormalization(momentum=0.8, name=name+'bn_dense')(g, training=True)\\n g = Activation(activation='relu', name=name+'relu')(g)\\n\\n g = self.Conv2DTranspose_Block(g, 4*filters, name=name+'1')\\n if index_rows==0 or index_cols==0:\\n g = BilinearUpsampling(output_size=(n_rows//4, n_cols//4), name=name+'bilinear')(g)\\n g = self.Conv2DTranspose_Block(g, 2*filters, k_size=k_size, name=name+'2')\\n if index_rows==1 or index_cols==1:\\n g = BilinearUpsampling(output_size=(n_rows//2, n_cols//2), name=name+'bilinear')(g)\\n g = self.Conv2DTranspose_Block(g, 1*filters, k_size=k_size, name=name+'3')\\n if index_rows==2 or index_cols==2:\\n g = BilinearUpsampling(output_size=(n_rows, n_cols), name=name+'bilinear')(g) \\n g = self.Conv2DTranspose_Block(g, c_dims, strides=1, activation='tanh', k_size=k_size, name=name+'4', bn=False)\\n\\n model = Model(inputs=[input_layer], outputs=[g], name='Generator')\\n if (summary):\\n model.summary()\\n return model\",\n \"def __init__(\\n self,\\n numpy_rng,\\n train_set_x,\\n train_set_y,\\n hidden_layers_sizes,\\n n_ins=784,\\n n_outs=10\\n ):\\n\\n self.sigmoid_layers = []\\n self.AE_layers = []\\n self.params = []\\n self.n_layers = len(hidden_layers_sizes)\\n self.train_set_x = train_set_x\\n self.train_set_y = train_set_y\\n\\n assert self.n_layers > 0\\n\\n self.x = T.matrix('x') # the data is presented as rasterized images\\n self.y = T.ivector('y') # the labels are presented as 1D vector of\\n\\n for i in xrange(self.n_layers): # used to be n layers\\n\\n # construct the sigmoid layer = encoder stack\\n if i == 0:\\n layer_input = self.x\\n else:\\n layer_input = self.sigmoid_layers[-1].output\\n\\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\\n input=layer_input,\\n n_in=(n_ins if i == 0 else\\n hidden_layers_sizes[i-1]),\\n n_out=hidden_layers_sizes[i],\\n activation=T.nnet.sigmoid)\\n\\n # add the layer to our list of layers\\n self.sigmoid_layers.append(sigmoid_layer)\\n self.params.extend(sigmoid_layer.params)\\n\\n # init the DA_layer, takes weights from sigmoid layer\\n AE_layer = AutoEncoder(\\n numpy_rng=numpy_rng,\\n input=layer_input,\\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\\n n_hidden=hidden_layers_sizes[i],\\n W=sigmoid_layer.W,\\n bhid=sigmoid_layer.b)\\n\\n self.AE_layers.append(AE_layer)\\n\\n # on top of the layers\\n # log layer for fine-tuning\\n self.logLayer = LogisticRegression(\\n input=self.sigmoid_layers[-1].output,\\n n_in=hidden_layers_sizes[-1],\\n n_out=n_outs\\n )\\n self.params.extend(self.logLayer.params)\\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\\n self.errors = self.logLayer.errors(self.y)\",\n \"def generate(self):\\n t_0 = time()\\n\\n if self.random_towers:\\n self.towers = np.random.rand(self.number_towers, 2)\\n else:\\n step = np.ceil(np.sqrt(self.number_towers)).astype('int')\\n\\n if step ** 2 != self.number_towers:\\n self.number_towers = step ** 2\\n print(f'WARNING: number of towers changed to {self.number_towers}')\\n\\n X, Y = np.mgrid[0:1:step * 1j, 0:1:step * 1j]\\n positions = np.vstack([X.ravel(), Y.ravel()])\\n self.towers = positions.swapaxes(1, 0)\\n\\n self.towers_manager = TowersManager(self.towers, self.vel_friction)\\n\\n self.distances = self.towers_manager.generate_distances()\\n self.print(f'Took {time() - t_0} to create distrances matrix')\\n\\n t = time()\\n self.probabilities = self.generate_probabilities()\\n self.print(f'Took {time() - t} to create probabilities matrix')\\n\\n t = time()\\n self.traces = self.generate_weighted_users_traces()\\n self.print(f'Took {time() - t} to create user traces')\\n\\n t = time()\\n self.aggregated_data = self.generate_aggregate_data()\\n self.print(f'Took {time() - t} to build aggregated data')\\n\\n self.print(f'Took {time() - t_0} to generate all')\",\n \"def create_matrix(self):\\n\\n self.matrix = np.zeros((len(self.users), len(self.items)))\\n\\n for user in self.train_set['users']:\\n for item in self.train_set['feedback'][user]:\\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\\\\n self.train_set['feedback'][user][item]\",\n \"def convert(self):\\n self.tilewidth = int(self.tilewidth)\\n self.tileheight = int(self.tileheight)\\n self.width = int(self.width)\\n self.height = int(self.height)\\n self.pixel_width = self.width * self.tilewidth\\n self.pixel_height = self.height * self.tileheight\\n for layer in self.layers:\\n self.named_layers[layer.name] = layer\\n layer.opacity = float(layer.opacity)\\n layer.x = int(layer.x)\\n layer.y = int(layer.y)\\n layer.width = int(layer.width)\\n layer.height = int(layer.height)\\n layer.pixel_width = layer.width * self.tilewidth\\n layer.pixel_height = layer.height * self.tileheight\\n layer.visible = bool(int(layer.visible))\\n for tile_set in self.tile_sets:\\n self.named_tile_sets[tile_set.name] = tile_set\\n tile_set.spacing = int(tile_set.spacing)\\n tile_set.margin = int(tile_set.margin)\\n for img in tile_set.images:\\n if img.trans:\\n img.trans = (int(img.trans[:2], 16), int(img.trans[2:4], 16), int(img.trans[4:], 16))\\n for obj_group in self.object_groups:\\n obj_group.x = int(obj_group.x)\\n obj_group.y = int(obj_group.y)\\n obj_group.width = int(obj_group.width)\\n obj_group.height = int(obj_group.height)\\n for map_obj in obj_group.objects:\\n map_obj.x = int(map_obj.x)\\n map_obj.y = int(map_obj.y)\\n map_obj.width = int(map_obj.width)\\n map_obj.height = int(map_obj.height)\",\n \"def convert(self):\\n self.tilewidth = int(self.tilewidth)\\n self.tileheight = int(self.tileheight)\\n self.width = int(self.width)\\n self.height = int(self.height)\\n self.pixel_width = self.width * self.tilewidth\\n self.pixel_height = self.height * self.tileheight\\n for layer in self.layers:\\n self.named_layers[layer.name] = layer\\n layer.opacity = float(layer.opacity)\\n layer.x = int(layer.x)\\n layer.y = int(layer.y)\\n layer.width = int(layer.width)\\n layer.height = int(layer.height)\\n layer.pixel_width = layer.width * self.tilewidth\\n layer.pixel_height = layer.height * self.tileheight\\n layer.visible = bool(int(layer.visible))\\n for tile_set in self.tile_sets:\\n self.named_tile_sets[tile_set.name] = tile_set\\n tile_set.spacing = int(tile_set.spacing)\\n tile_set.margin = int(tile_set.margin)\\n for img in tile_set.images:\\n if img.trans:\\n img.trans = (int(img.trans[:2], 16), int(img.trans[2:4], 16), int(img.trans[4:], 16))\\n for obj_group in self.object_groups:\\n obj_group.x = int(obj_group.x)\\n obj_group.y = int(obj_group.y)\\n obj_group.width = int(obj_group.width)\\n obj_group.height = int(obj_group.height)\\n for map_obj in obj_group.objects:\\n map_obj.x = int(map_obj.x)\\n map_obj.y = int(map_obj.y)\\n map_obj.width = int(map_obj.width)\\n map_obj.height = int(map_obj.height)\",\n \"def build_generator2D(self, model_shape, filters=32, k_size=4, z_size=500, summary=False, model_file=None, name='gan_g_'):\\n if (model_file):\\n \\\"\\\"\\\"\\n Load pretreined model\\n \\\"\\\"\\\"\\n model = self.utils.build_pretrained_model(model_file)\\n if (summary):\\n model.summary()\\n return model\\n else:\\n\\n n_rows = model_shape[0]\\n n_cols = model_shape[1]\\n input_shape = (z_size,)\\n if n_rows % 8 !=0:\\n height = n_rows//8 + 1\\n else:\\n height = n_rows//8\\n if n_cols % 8 !=0:\\n width = n_cols//8 +1\\n else:\\n width = n_cols//8\\n \\n num_init_neurons = 8*filters \\n reshape_size= (height, width, num_init_neurons)\\n \\n # 8*height, 4*height, 2*height, height = n_rows, n_rows//2, n_rows//4, n_rows//8\\n rows_matching = np.equal([2*height, 4*height, 8*height], [n_rows//4, n_rows//2, n_rows])\\n index_rows = np.where(np.logical_not(rows_matching))[0]\\n if len(index_rows) > 0:\\n index_rows = index_rows[0]\\n # print(index_rows)\\n # 8*width, 4*width, 2*width, width = n_cols//1, n_cols//2, n_cols//4, n_cols//8\\n cols_matching = np.equal([2*width, 4*width, 8*width], [n_cols//4, n_cols//2, n_cols])\\n index_cols = np.where(np.logical_not(cols_matching))[0]\\n if len (index_cols) > 0:\\n index_cols = index_cols[0]\\n # print(index_cols)\\n\\n input_layer = Input(shape=input_shape, name=name+'input')\\n g = Dense(width * height * num_init_neurons, kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(input_layer)\\n g = Reshape(reshape_size, name=name+'reshape')(g)\\n g = BatchNormalization(momentum=0.8, name=name+'bn_dense')(g, training=True)\\n g = Activation(activation='relu', name=name+'relu')(g)\\n\\n g = self.Conv2DTranspose_Block(g, 4*filters, name=name+'1')\\n if index_rows==0 or index_cols==0:\\n g = BilinearUpsampling(output_size=(n_rows//4, n_cols//4), name=name+'bilinear')(g)\\n g = self.Conv2DTranspose_Block(g, 2*filters, k_size=k_size, name=name+'2')\\n if index_rows==1 or index_cols==1:\\n g = BilinearUpsampling(output_size=(n_rows//2, n_cols//2), name=name+'bilinear')(g)\\n g = self.Conv2DTranspose_Block(g, 1*filters, k_size=k_size, name=name+'3')\\n if index_rows==2 or index_cols==2:\\n g = BilinearUpsampling(output_size=(n_rows, n_cols), name=name+'bilinear')(g) \\n g = self.Conv2DTranspose_Block(g, 2, strides=1, activation='tanh', k_size=k_size, name=name+'4', bn=False)\\n\\n model = Model(inputs=[input_layer], outputs=[g], name='Generator')\\n if (summary):\\n model.summary()\\n return model\",\n \"def MeshMachine(main):\\n\\n # oDesign definition\\n oDesign = main['ANSYS']['oDesign']\\n\\n # Data for the rotor mesh\\n RotorName = main['ANSYS']['Rotor&Magnets']['Name'][0]\\n RotorNumMaxElem = main['ANSYS']['Mesh']['Rotor']['NumMaxElem']\\n RotorMaxLength = main['ANSYS']['Mesh']['Rotor']['MaxLength']\\n\\n # Data for the magnets mesh\\n PMNames = main['ANSYS']['Rotor&Magnets']['PMNames']\\n PMNumMaxElem = main['ANSYS']['Mesh']['Magnets']['NumMaxElem']\\n PMMaxLength = main['ANSYS']['Mesh']['Magnets']['MaxLength']\\n\\n # Data for the Stator mesh\\n StatorName = main['ANSYS']['Stator']['Name']\\n StatorNormalDev = main['ANSYS']['Mesh']['Stator']['NormalDev']\\n StatorAspectRatio = main['ANSYS']['Mesh']['Stator']['AspectRatio']\\n\\n # Data for the Stator mesh\\n CoilNames = main['ANSYS']['Winding']['CoilNames']\\n WindingNumMaxElem = main['ANSYS']['Mesh']['Winding']['NumMaxElem']\\n WindingMaxLength = main['ANSYS']['Mesh']['Winding']['MaxLength']\\n\\n WindingName = []\\n for phase in CoilNames:\\n for direction in phase:\\n WindingName += direction\\n\\n # Creating meshes\\n oModule = oDesign.GetModule(\\\"MeshSetup\\\")\\n\\n # Rotor meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Rotor\\\",\\n \\\"RefineInside:=\\\", True,\\n \\\"Enabled:=\\\", True,\\n \\\"Objects:=\\\", [RotorName],\\n \\\"RestrictElem:=\\\", False,\\n \\\"NumMaxElem:=\\\", str(RotorNumMaxElem),\\n \\\"RestrictLength:=\\\", True,\\n \\\"MaxLength:=\\\", str(RotorMaxLength)+\\\"mm\\\"\\n ]\\n )\\n # Magnet meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Magnets\\\",\\n \\\"RefineInside:=\\\", True,\\n \\\"Enabled:=\\\", True,\\n \\\"Objects:=\\\", PMNames,\\n \\\"RestrictElem:=\\\", False,\\n \\\"NumMaxElem:=\\\", str(PMNumMaxElem),\\n \\\"RestrictLength:=\\\", True,\\n \\\"MaxLength:=\\\", str(PMMaxLength)+\\\"mm\\\"\\n ]\\n )\\n # Stator meshes\\n oModule.AssignTrueSurfOp(\\n [\\n \\\"NAME:Stator\\\",\\n \\\"Objects:=\\\", [StatorName],\\n \\\"CurvedSurfaceApproxChoice:=\\\", \\\"ManualSettings\\\",\\n \\\"SurfDevChoice:=\\\", 0,\\n \\\"NormalDevChoice:=\\\", 2,\\n \\\"NormalDev:=\\\", str(StatorNormalDev) + \\\"deg\\\",\\n \\\"AspectRatioChoice:=\\\", 2,\\n \\\"AspectRatio:=\\\", str(StatorAspectRatio)\\n ]\\n )\\n\\n # Coil meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Coils\\\",\\n \\\"RefineInside:=\\\"\\t, True,\\n \\\"Enabled:=\\\"\\t\\t, True,\\n \\\"Objects:=\\\"\\t\\t, WindingName,\\n \\\"RestrictElem:=\\\"\\t, False,\\n \\\"NumMaxElem:=\\\"\\t\\t, str(WindingNumMaxElem),\\n \\\"RestrictLength:=\\\"\\t, True,\\n \\\"MaxLength:=\\\"\\t\\t, str(WindingMaxLength) +\\\"mm\\\"\\n ]\\n )\\n\\n return main\",\n \"def build_mat(self):\\n for row, s in enumerate(self.S):\\n for col, t in enumerate(self.T):\\n\\n if self.symmetric and row > col:\\n pass\\n\\n else:\\n self.mat[row, col] = self.kernel(s, t, self.n)\\n\\n if self.symmetric:\\n self.mat = self.symmetrize(self.mat)\\n else:\\n for idx, s in enumerate(self.S):\\n self.test_normalization[idx] = self.kernel(s, s, self.n)\",\n \"def build(classes):\\n # data input\\n data = mx.sym.Variable(\\\"data\\\")\\n\\n # Block #1: first CONV => RELU => POOL layer set\\n conv1_1 = mx.sym.Convolution(data=data, kernel=(11, 11), stride=(4, 4), num_filter=96)\\n act1_1 = mx.sym.LeakyReLU(data=conv1_1, act_type=\\\"elu\\\")\\n bn1_1 = mx.sym.BatchNorm(data=act1_1)\\n pool1 = mx.sym.Pooling(data=bn1_1, pool_type=\\\"max\\\", kernel=(3, 3), stride=(2, 2))\\n do1 = mx.sym.Dropout(data=pool1, p=0.25)\\n\\n # Block #2: second CONV => RELU => POOL layer set\\n conv2_1 = mx.sym.Convolution(data=do1, kernel=(5, 5), pad=(2, 2), num_filter=256)\\n act2_1 = mx.sym.LeakyReLU(data=conv2_1, act_type=\\\"elu\\\")\\n bn2_1 = mx.sym.BatchNorm(data=act2_1)\\n pool2 = mx.sym.Pooling(data=bn2_1, pool_type=\\\"max\\\", kernel=(3, 3), stride=(2, 2))\\n do2 = mx.sym.Dropout(data=pool2, p=0.25)\\n\\n # Block #3: (CONV => RELU) * 3 => POOL\\n conv3_1 = mx.sym.Convolution(data=do2, kernel=(3, 3), pad=(1, 1), num_filter=384)\\n act3_1 = mx.sym.LeakyReLU(data=conv3_1, act_type=\\\"elu\\\")\\n bn3_1 = mx.sym.BatchNorm(data=act3_1)\\n conv3_2 = mx.sym.Convolution(data=bn3_1, kernel=(3, 3), pad=(1, 1), num_filter=384)\\n act3_2 = mx.sym.LeakyReLU(data=conv3_2, act_type=\\\"elu\\\")\\n bn3_2 = mx.sym.BatchNorm(data=act3_2)\\n conv3_3 = mx.sym.Convolution(data=bn3_2, kernel=(3, 3), pad=(1, 1), num_filter=256)\\n act3_3 = mx.sym.LeakyReLU(data=conv3_3, act_type=\\\"elu\\\")\\n bn3_3 = mx.sym.BatchNorm(data=act3_3)\\n pool3 = mx.sym.Pooling(data=bn3_3, pool_type=\\\"max\\\", kernel=(3, 3), stride=(2, 2))\\n do3 = mx.sym.Dropout(data=pool3, p=0.25)\\n\\n # Block #4: first set of FC => RELU layers\\n flatten = mx.sym.Flatten(data=do3)\\n fc1 = mx.sym.FullyConnected(data=flatten, num_hidden=4096)\\n act4_1 = mx.sym.LeakyReLU(data=fc1, act_type=\\\"elu\\\")\\n bn4_1 = mx.sym.BatchNorm(data=act4_1)\\n do4 = mx.sym.Dropout(data=bn4_1, p=0.5)\\n\\n # Block #5: second set of FC => RELU layers\\n fc2 = mx.sym.FullyConnected(data=do4, num_hidden=4096)\\n act5_1 = mx.sym.LeakyReLU(data=fc2, act_type=\\\"elu\\\")\\n bn5_1 = mx.sym.BatchNorm(data=act5_1)\\n do5 = mx.sym.Dropout(data=bn5_1, p=0.5)\\n\\n # softmax classifier\\n fc3 = mx.sym.FullyConnected(data=do5, num_hidden=classes)\\n model = mx.sym.SoftmaxOutput(data=fc3, name=\\\"softmax\\\")\\n\\n # return the network architecture\\n return model\",\n \"def generate_tiles(self):\\n if self.children:\\n for child in self.children:\\n child.generate_tiles()\\n print \\\"Generating tile for %s using child tiles\\\" % self.bbox\\n self.generate_tile_from_child_tiles()\\n else:\\n print \\\"Generating tile for %s using source data\\\" % self.bbox\\n self.generate_tile_from_source()\",\n \"def drawMatrix(self,screen,pos):\\n bp = pos # base position bp\\n namesurface = myfont.render(self.parentname, False, self.parentcolour)\\n screen.blit(namesurface,(bp[0]-50,bp[1] -60),) \\n tempOffset = namesurface.get_width()\\n namesurface = myfont.render(self.name, False, self.colour)\\n screen.blit(namesurface,(bp[0]-40 ,bp[1]-30),) \\n size = 10\\n separationx = 12\\n separationy = 20\\n # Cycle through array of inputs\\n for i in range(self.dimensions[0]):\\n # Create red - green colour based on array\\n temp_colour = (int((1-self.scan[i])*240),int(self.scan[i]*240),0)\\n # Draw square that is slightly offset of previous square\\n pygame.draw.rect(screen,temp_colour ,(bp[0] - separationx *int(i / len(self.inputdistance)),\\n bp[1] - separationx*(i%len(self.inputdistance)) + 3*separationx,size,size))\\n # Calculate intermediate decision array\\n temp_vector = self.scan \\n # Repeat\\n for j, bs in enumerate(self.bias):\\n temp_vector = np.add(temp_vector.dot(self.weights[j]), bs)\\n for i in range(temp_vector.shape[0]):\\n temp_colour = (int(max(min((1-temp_vector[i])*240,240),0)),int(max(min(temp_vector[i]*240,240),0)),0)\\n pygame.draw.rect(screen,temp_colour ,(bp[0] + (j+1)*separationy,bp[1] + separationx*i,size,size))\",\n \"def _make_random_matrix(self, n_components, n_features):\",\n \"def _build_matrix(self, image):\\n offset_generator = self._iter_images_rects()\\n count = 1\\n for src_image in self._iter_images():\\n pos_x, pos_y, max_w, max_h = next(offset_generator)\\n src_image, width, height = self._image_resize_keep_ratio(src_image, max_w, max_h, self._crop)\\n # Adjust position to have identical margin between borders and images\\n if len(self._images) < 4:\\n pos_x, pos_y = pos_x + (max_w - width) // 2, pos_y + (max_h - height) // 2\\n elif count == 1:\\n pos_x, pos_y = pos_x + (max_w - width) * 2 // 3, pos_y + (max_h - height) * 2 // 3\\n elif count == 2:\\n pos_x, pos_y = pos_x + (max_w - width) // 3, pos_y + (max_h - height) * 2 // 3\\n elif count == 3:\\n pos_x, pos_y = pos_x + (max_w - width) * 2 // 3, pos_y + (max_h - height) // 3\\n else:\\n pos_x, pos_y = pos_x + (max_w - width) // 3, pos_y + (max_h - height) // 3\\n\\n self._image_paste(src_image, image, pos_x, pos_y)\\n count += 1\\n return image\",\n \"def compile(self):\\n self.train = self._make_train()\\n self.loss_test = self._make_loss_test()\\n self.predict = self._make_predict()\",\n \"def setUp(self):\\r\\n self.matrix = array(\\r\\n [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])\\r\\n self.cells = [(0, 1), (1, 3)]\\r\\n self.cells2 = [(0, 2), (2, 3)]\",\n \"def generate():\",\n \"def generate(self):\",\n \"def gen_matrix(e):\\n\\tif e < 1:\\n\\t\\treturn None\\n\\tm_list = [[[1, 2], [3, 0]]]\\n\\t_b = m_list[0]\\n\\tfor n in xrange(1, e):\\n\\t\\tm = m_list[n - 1]\\n\\t\\tm_list.append(\\n\\t\\t\\t[\\n\\t\\t\\t\\t[4 * i + _b[0][0] for i in m[0]] + [4 * i + _b[0][1] for i in m[0]],\\n\\t\\t\\t\\t[4 * i + _b[0][0] for i in m[1]] + [4 * i + _b[0][1] for i in m[1]],\\n\\t\\t\\t\\t[4 * i + _b[1][0] for i in m[0]] + [4 * i + _b[1][1] for i in m[0]],\\n\\t\\t\\t\\t[4 * i + _b[1][0] for i in m[1]] + [4 * i + _b[1][1] for i in m[1]],\\n\\t\\t\\t]\\n\\t\\t)\\n\\treturn m_list\",\n \"def _initializeMatrices(self):\\n K = self.K \\n # Initialize Initia\\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\\n rand_initial_prob = list(rand_initial_prob[0,:])\\n for i in range(K): \\n self.state_initial_prob[i+1] = rand_initial_prob[i]\\n\\n # Initialize the transition MAtrix !\\n for i in range(K):\\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\\n rand_initial_prob = list(rand_initial_prob[0,:]) \\n\\n for j in range(K):\\n self.state_transition_mat[(j+1,i+1)] = rand_initial_prob[j]\\n\\n\\n # Initialize the symbol distribution Parameters ui and si (Assuming a numeric outputs ! Modelled using a gaussian ! withmean ui and std si)\\n init_mean = np.mean(self.data_matrix)\\n init_std = np.std(self.data_matrix) \\n \\n for i in range(K):\\n random_mean = gauss(init_mean,30)\\n random_std = gauss(init_std,30)\\n self.state_symbol_prob[i+1] = {'mean':random_mean, 'std' : random_std}\",\n \"def create_output_matrix_files(self, year, max_zone_id):\\r\\n from opus_emme2.travel_model_output import TravelModelOutput\\r\\n tm_output = TravelModelOutput(self.emme_cmd)\\r\\n year_config = self.config['travel_model_configuration'][year]\\r\\n for x in 1,2,3:\\r\\n if \\\"bank%i\\\" % x in year_config['matrix_variable_map']:\\r\\n bank_dir = self.get_emme2_dir(year, \\\"bank%i\\\" % x)\\r\\n for matrix_name in year_config['matrix_variable_map'][\\\"bank%i\\\" % x].keys():\\r\\n tm_output._get_matrix_into_data_file(matrix_name, max_zone_id, bank_dir, \\\"%s_one_matrix.txt\\\" % matrix_name)\",\n \"def build_layers(self):\\n raise NotImplementedError\",\n \"def make_input_map(self) :\\n\\n self.input_map = \\\"\\\"\\n stencil = self.core.stencil\\n pattern = self.core.pattern\\n reflect = len(pattern)+1 # reflector id, last material\\n N = self.dimension\\n coremap = np.zeros((N+2,N+2), dtype='i')\\n \\n # reflections and vacuum\\n coremap[0, 1:N+1] = -1 \\n coremap[1:N+1, 0] = -1\\n coremap[N+1, 1:N+1] = -2\\n coremap[1:N+1, N+1] = -2\\n \\n fuelindex = 0\\n \\n for i in range(1, N+1) :\\n for j in range(1, N+1) :\\n if j == 1 and i > 1 :\\n pass\\n else :\\n if stencil[i-1, j-1] > 0 : # a fuel\\n coremap[i, j] = pattern[fuelindex]+1\\n fuelindex += 1\\n elif stencil[i-1, j-1] == 0 : # a reflector\\n coremap[i, j] = reflect\\n else : # a void\\n pass \\n # Copy elements such that rotational symmetry is enforced. \\n for j in range(2, N+1) :\\n coremap[j, 1] = coremap[1, j]\\n for i in range(0, N+2) :\\n for j in range(0, N+2) :\\n self.input_map +='%4i' % (coremap[i, j])\\n self.input_map += '\\\\n'\",\n \"def _init_model(self):\\n self.A_inv = np.zeros(shape=(self.numUsers, self.d, self.d))\\n self.b = np.zeros(shape=(self.numUsers, self.d))\\n self.w = np.zeros(shape=(self.numUsers, self.d))\\n for i, mat in enumerate(self.A_inv):\\n self.A_inv[i] = np.eye(self.d)\",\n \"def build(self):\\n\\n self.W_AA = self.init([self.n_atom_input_feat, self.n_hidden_AA])\\n self.b_AA = model_ops.zeros(shape=[\\n self.n_hidden_AA,\\n ])\\n\\n self.W_PA = self.init([self.n_pair_input_feat, self.n_hidden_PA])\\n self.b_PA = model_ops.zeros(shape=[\\n self.n_hidden_PA,\\n ])\\n\\n self.W_A = self.init([self.n_hidden_A, self.n_atom_output_feat])\\n self.b_A = model_ops.zeros(shape=[\\n self.n_atom_output_feat,\\n ])\\n\\n self.trainable_weights = [\\n self.W_AA, self.b_AA, self.W_PA, self.b_PA, self.W_A, self.b_A\\n ]\\n if self.update_pair:\\n self.W_AP = self.init([self.n_atom_input_feat * 2, self.n_hidden_AP])\\n self.b_AP = model_ops.zeros(shape=[\\n self.n_hidden_AP,\\n ])\\n\\n self.W_PP = self.init([self.n_pair_input_feat, self.n_hidden_PP])\\n self.b_PP = model_ops.zeros(shape=[\\n self.n_hidden_PP,\\n ])\\n\\n self.W_P = self.init([self.n_hidden_P, self.n_pair_output_feat])\\n self.b_P = model_ops.zeros(shape=[\\n self.n_pair_output_feat,\\n ])\\n\\n self.trainable_weights.extend(\\n [self.W_AP, self.b_AP, self.W_PP, self.b_PP, self.W_P, self.b_P])\",\n \"def _build(self):\\n with tf.variable_scope (self.name + '_architecutre') as scope:\\n images_square = unflatten_layer ( self.images )\\n visualize_images(images_square)\\n\\n # Conv Layer 1\\n conv1_out, params = conv_2d_layer ( input = images_square,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n name = 'enc_conv_1',\\n visualize = True )\\n process_params(params, name = self.name)\\n e1_params = params\\n pool1_out = max_pool_2d_layer ( input = conv1_out, name = 'enc_pool_1')\\n # lrn1_out = local_response_normalization_layer (pool1_out, name = 'lrn_1' )\\n\\n # Conv Layer 2\\n conv2_out, params = conv_2d_layer ( input = pool1_out,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n name = 'enc_conv_2' )\\n process_params(params, name = self.name)\\n e2_params = params\\n pool2_out = max_pool_2d_layer ( input = conv2_out, name = 'enc_pool_2')\\n # lrn2_out = local_response_normalization_layer (pool2_out, name = 'lrn_2' )\\n\\n flattened = flatten_layer(pool2_out)\\n\\n # Dropout Layer 1 \\n flattened_dropout = dropout_layer ( input = flattened,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_1') \\n\\n # Dot Product Layer 1\\n fc1_out, params = dot_product_layer ( input = flattened_dropout,\\n neurons = HIDDEN_1,\\n name = 'enc_dot_1')\\n process_params(params, name = self.name)\\n e3_params = params \\n\\n # Dropout Layer 2 \\n fc1_out_dropout = dropout_layer ( input = fc1_out,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_2')\\n # Dot Product Layer 2\\n fc2_out, params = dot_product_layer ( input = fc1_out_dropout, \\n neurons = HIDDEN_2,\\n name = 'enc_dot_2')\\n process_params(params, name = self.name)\\n e4_params = params \\n\\n # Dropout Layer 3 \\n fc2_out_dropout = dropout_layer ( input = fc2_out,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_3')\\n \\n # Dot Product Layer 2\\n self.codeword, params = dot_product_layer ( input = fc2_out_dropout, \\n neurons = CODEWORD_LENGTH,\\n activation = CODE_ACTIVATION,\\n name = 'enc_dot_2')\\n process_params(params, name = self.name)\\n process_codeword_normalization_regularizer(self.codeword, \\n coeff = AUTOENCODER_CODEWORD_COEFF,\\n name = self.name)\\n e5_params = params \\n # tf.summary.histogram('codewords', self.codeword)\\n # self.hash = threshold_layer ( input = self.codeword,\\n # name = 'hash')\\n # process_hash_regularizer(self.codeword, coeff = AUTOENCODER_HASH_COEFF,\\n # name = self.name)\\n\\n # Decoder ... \\n decoder_1_out, params = dot_product_layer ( input = self.codeword, \\n neurons = HIDDEN_2,\\n params = [tf.transpose(e5_params[0]), None],\\n name = 'decoder_dot_1')\\n d1_params = params\\n process_params([params[1]], name = self.name)\\n \\n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\\n prob = self.dropout_prob,\\n name = 'dec_dropout_1')\\n\\n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \\n neurons = HIDDEN_1,\\n params = [tf.transpose(e4_params[0]), None],\\n name = 'decoder_dot_2')\\n d2_params = params\\n process_params([params[1]], name = self.name)\\n \\n # dropout 2\\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\\n prob = self.dropout_prob,\\n name = 'dec_dropout_2')\\n\\n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \\n neurons = 1250,\\n params = [tf.transpose(e3_params[0]), None],\\n name = 'decoder_dot_3')\\n d3_params = params\\n process_params([params[1]], name = self.name)\\n\\n # DeConv Layer 1\\n # The output shapes need to be changed according to architecture.\\n\\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N )\\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), name = 'dec_upsampling_1')\\n\\n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\\n neurons = CONV_1_N,\\n filter_size = CONV_2_FILT,\\n output_shape = (12,12),\\n # n_outs = MINI_BATCH_SIZE,\\n stride = (1,1,1,1), \\n params = [e2_params[0], None], \\n name = 'dec_deconv_1' )\\n\\n process_params([params[1]], name = self.name)\\n d4_params = params\\n\\n # DeConv Layer 2\\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), name = 'dec_upsampling_2')\\n decoded_images_square, params = deconv_2d_layer ( input = upsample_2,\\n neurons = 1,\\n filter_size = CONV_1_FILT,\\n stride = (1,1,1,1),\\n output_shape = (28,28),\\n # n_outs = MINI_BATCH_SIZE, \\n params = [e1_params[0], None], \\n activation = 'tanh', \\n name = 'dec_deconv_2' )\\n \\n process_params([params[1]], name = self.name)\\n d5_params = params \\n \\n self.decoded = flatten_layer (decoded_images_square, in_shp = [-1, 28, 28, 1])\\n visualize_images(decoded_images_square, name = 'decoded')\\n # This is because transpose don't initialize.\\n self.params = [ [e5_params[0], d1_params[1] ],\\n [e4_params[0], d2_params[1] ],\\n [e3_params[0], d3_params[1] ],\\n [e2_params[0], d4_params[1] ],\\n [e1_params[0], d5_params[1] ] ]\\n\\n with tf.variable_scope (self.name + '_objectives') as scope: \\n with tf.variable_scope( self.name + '_decoder_error') as scope:\\n reconstruction_error = rmse(self.images, self.decoded) \\n tf.add_to_collection( self.name + '_objectives', reconstruction_error ) \\n tf.summary.scalar('reconstruction_error', reconstruction_error)\\n\\n self._cook_optimizer( \\n lr = AUTOENCODER_LR, \\n optimizer = AUTOENCODER_OPTIMIZER,\\n l1_coeff = AUTOENCODER_L1_COEFF,\\n l2_coeff = AUTOENCODER_WEIGHT_DECAY_COEFF)\",\n \"def _init_layers(self) -> None:\\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\\n self.cross_attn = MultiheadAttention(**self.cross_attn_cfg)\\n self.embed_dims = self.self_attn.embed_dims\\n self.ffn = FFN(**self.ffn_cfg)\\n norms_list = [\\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\\n for _ in range(3)\\n ]\\n self.norms = ModuleList(norms_list)\",\n \"def build(self):\\n\\n self.W = self.init([self.n_atom_input_feat, self.n_output])\\n self.b = model_ops.zeros(shape=[\\n self.n_output,\\n ])\\n\\n self.trainable_weights = self.W + self.b\",\n \"def generate_mos(laygen, objectname_pfix, placement_grid, routing_grid_m1m2, devname_mos_boundary, devname_mos_body,\\n devname_mos_dmy, m=1, m_dmy=0, origin=np.array([0,0])):\\n pg = placement_grid\\n rg12 = routing_grid_m1m2\\n pfix = objectname_pfix\\n\\n # placement\\n imbl0 = laygen.relplace(name=\\\"I\\\" + pfix + 'BL0', templatename=devname_mos_boundary, gridname=pg, xy=origin)\\n refi=imbl0\\n if not m_dmy==0:\\n imdmyl0 = laygen.relplace(name=\\\"I\\\" + pfix + 'DMYL0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\\n refi=imdmyl0\\n else:\\n imdmyl0 = None\\n im0 = laygen.relplace(name=\\\"I\\\" + pfix + '0', templatename=devname_mos_body, gridname=pg, refobj=refi, shape=[m, 1])\\n refi=im0\\n if not m_dmy==0:\\n imdmyr0 = laygen.relplace(name=\\\"I\\\" + pfix + 'DMYR0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\\n refi=imdmyr0\\n else:\\n imdmyr0 = None\\n imbr0 = laygen.relplace(name=\\\"I\\\" + pfix + 'BR0', templatename=devname_mos_boundary, gridname=pg, refobj=imdmyr0)\\n md=im0.elements[:, 0]\\n #route\\n #gate\\n rg0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['G0'], refobj1=md[-1].pins['G0'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['G0'], gridname=rg12)\\n #drain\\n rdl0=laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=md[0].pins['D0'], refobj1=md[-1].pins['D0'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 1], refobj=_md.pins['D0'], gridname=rg12)\\n #source\\n rs0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['S0'], refobj1=md[-1].pins['S1'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['S0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=md[-1].pins['S1'], gridname=rg12)\\n #dmy\\n if m_dmy>=2:\\n mdmyl=imdmyl0.elements[:, 0]\\n mdmyr=imdmyr0.elements[:, 0]\\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyl[0].pins['D0'], refobj1=mdmyl[-1].pins['D0'])\\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyr[0].pins['D0'], refobj1=mdmyr[-1].pins['D0'])\\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyl[0].pins['S0'], refobj1=mdmyl[-1].pins['S1'])\\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyr[0].pins['S0'], refobj1=mdmyr[-1].pins['S1'])\\n for _mdmyl in mdmyl:\\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyl.pins['D0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyl.pins['S0'], gridname=rg12)\\n for _mdmyr in mdmyr:\\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyr.pins['D0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyr.pins['S1'], gridname=rg12)\\n return [imbl0, imdmyl0, im0, imdmyr0, imbr0]\",\n \"def initialize_matrices(self):\\n assert self._training_dataset and self._valid_dataset\\n # inject prior knowledge about transition and emission\\n self._state_prior = torch.zeros(self._config.d_hidden, device=self._config.device) + 1e-2\\n self._state_prior[0] += 1 - self._state_prior.sum()\\n\\n intg_obs = list(map(np.array, self._training_dataset.obs + self._valid_dataset.obs))\\n self._trans_mat = torch.tensor(initialise_transmat(\\n observations=intg_obs, label_set=self._config.bio_label_types)[0], dtype=torch.float)\\n self._emiss_mat = torch.tensor(initialise_emissions(\\n observations=intg_obs, label_set=self._config.bio_label_types,\\n sources=self._config.sources, src_priors=self._config.src_priors\\n )[0], dtype=torch.float)\\n return self\",\n \"def generate_features(self):\\n content_input = self.content_image * 255\\n style_input = self.style_image * 255\\n preprocessed_content = tf.keras.applications.vgg19.preprocess_input(\\n content_input)\\n preprocessed_style = tf.keras.applications.vgg19.preprocess_input(\\n style_input)\\n outputs_content = self.model(preprocessed_content)\\n outputs_style = self.model(preprocessed_style)\\n\\n num_style_layers = tf.size(self.style_layers)\\n style_outputs, content_outputs = (\\n outputs_style[:num_style_layers],\\n outputs_content[num_style_layers:])\\n\\n style_outputs = [self.gram_matrix(\\n style_output)for style_output in style_outputs]\\n self.gram_style_features = style_outputs\\n self.content_feature = content_outputs\",\n \"def _build(self, z, targets= None, input_params = None):\\n with tf.variable_scope (self.name + '_architecture') as scope:\\n with tf.variable_scope ( 'generator') as scope:\\n self.z = z\\n self.targets =targets\\n\\n # Dot Product Layer 1\\n par = input_params[0]\\n process_params(par, name = self.name) \\n par[0] = tf.transpose(par[0]) \\n # Decoder ... \\n decoder_1_out, params = dot_product_layer ( input = self.z, \\n neurons = HIDDEN_2,\\n params = par,\\n name = 'gen_decoder_dot_1')\\n g1_params = params\\n \\n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\\n prob = self.dropout_prob,\\n name = 'gen_dropout_1')\\n\\n # Dot Product Layer 2 \\n par = input_params[1]\\n process_params(par, name = self.name) \\n par[0] = tf.transpose(par[0]) \\n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \\n neurons = HIDDEN_1,\\n params = par,\\n name = 'gen_decoder_dot_2')\\n g2_params = params\\n\\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\\n prob = self.dropout_prob,\\n name = 'gen_dropout_2')\\n\\n # Dot Product Layer 3 \\n par = input_params[2]\\n process_params(par, name = self.name) \\n par[0] = tf.transpose(par[0]) \\n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \\n neurons = 1250,\\n params = par,\\n name = 'gen_decoder_dot_0')\\n g3_params = params\\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N,\\n name = 'gen_unflatten' )\\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), \\n name = 'gen_upsampling_1')\\n\\n # Convolution layer 1\\n par = input_params[3]\\n process_params(par, name = self.name) \\n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\\n neurons = CONV_1_N,\\n filter_size = CONV_2_FILT,\\n output_shape = (12,12),\\n params = par, \\n name = 'deconv_1' )\\n\\n g4_params = params\\n\\n # DeConv Layer 2\\n par = input_params[4]\\n process_params(par, name = self.name)\\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), \\n name = 'gen_upsampling_2')\\n generated_images_square, params = deconv_2d_layer ( \\n input = upsample_2,\\n neurons = 1,\\n filter_size = CONV_1_FILT,\\n stride = (1,1,1,1),\\n output_shape = (28,28),\\n params = par, \\n activation = 'tanh', \\n name = 'conv_2' )\\n \\n g5_params = params\\n self.generation = flatten_layer (generated_images_square, in_shp = [-1, 28, 28, 1])\\n visualize_images(generated_images_square, name = 'generated_images')\\n self.params = [g1_params, g2_params, g3_params, g4_params, g5_params]\",\n \"def _build_forward_graph(self):\\n\\n print('[*] Building a Neural Turing Machine.')\\n\\n self._initalize_state()\\n\\n # present start token\\n controller_out = self.controller.emit_feature_vector(self.start_token, self.r_t[0], reuse=None)\\n self._read_write(controller_out, reuse=None)\\n\\n # present inputs\\n print('Input chain: ')\\n for t in range(0, self.sequence_length):\\n print_progress(float(t + 1) / self.sequence_length)\\n\\n controller_out = self.controller.emit_feature_vector(self.inputs[t], self.r_t[-1], reuse=True)\\n self._read_write(controller_out, reuse=True)\\n\\n # present end token\\n controller_out = self.controller.emit_feature_vector(self.end_token, self.r_t[-1], reuse=True)\\n self._read_write(controller_out, reuse=True)\\n\\n # present outputs\\n print('Output chain: ')\\n for t in range(0, self.sequence_length):\\n print_progress(float(t + 1) / self.sequence_length)\\n\\n controller_out = self.controller.emit_feature_vector(self.zeros, self.r_t[-1], reuse=True)\\n self._read_write(controller_out, reuse=True)\\n\\n reuse = None if t == 0 else True\\n self.outputs.append(self._decode_read_vector(self.r_t[-1], reuse=reuse))\\n print('Done.')\",\n \"def _build_all_models(self):\\r\\n self.output_tensors = {}\\r\\n self.loss_terms = {}\\r\\n self.metrics = {}\\r\\n\\r\\n def _build_datasource_summaries(data_sources, mode):\\r\\n \\\"\\\"\\\"Register summary operations for input data from given data sources.\\\"\\\"\\\"\\r\\n with tf.variable_scope('%s_data' % mode):\\r\\n for data_source_name, data_source in data_sources.items():\\r\\n tensors = data_source.output_tensors\\r\\n for key, tensor in tensors.items():\\r\\n summary_name = '%s/%s' % (data_source_name, key)\\r\\n shape = tensor.shape.as_list()\\r\\n num_dims = len(shape)\\r\\n if num_dims == 4: # Image data\\r\\n if shape[1] == 1 or shape[1] == 3:\\r\\n self.summary.image(summary_name, tensor,\\r\\n data_format='channels_first')\\r\\n elif shape[3] == 1 or shape[3] == 3:\\r\\n self.summary.image(summary_name, tensor,\\r\\n data_format='channels_last')\\r\\n # TODO: fix issue with no summary otherwise\\r\\n elif num_dims == 2:\\r\\n self.summary.histogram(summary_name, tensor)\\r\\n else:\\r\\n logger.debug('I do not know how to create a summary for %s (%s)' %\\r\\n (summary_name, tensor.shape.as_list()))\\r\\n\\r\\n def _build_train_or_test(mode):\\r\\n data_sources = self._train_data if mode == 'train' else self._test_data\\r\\n\\r\\n # Build model\\r\\n output_tensors, loss_terms, metrics = self.build_model(data_sources, mode=mode)\\r\\n\\r\\n # Record important tensors\\r\\n self.output_tensors[mode] = output_tensors\\r\\n self.loss_terms[mode] = loss_terms\\r\\n self.metrics[mode] = metrics\\r\\n\\r\\n # Create summaries for scalars\\r\\n if mode == 'train':\\r\\n for name, loss_term in loss_terms.items():\\r\\n self.summary.scalar('loss/%s/%s' % (mode, name), loss_term)\\r\\n for name, metric in metrics.items():\\r\\n self.summary.scalar('metric/%s/%s' % (mode, name), metric)\\r\\n\\r\\n # Build the main model\\r\\n if len(self._train_data) > 0:\\r\\n _build_datasource_summaries(self._train_data, mode='train')\\r\\n _build_train_or_test(mode='train')\\r\\n logger.info('Built model.')\\r\\n\\r\\n # Print no. of parameters and lops\\r\\n flops = tf.profiler.profile(\\r\\n options=tf.profiler.ProfileOptionBuilder(\\r\\n tf.profiler.ProfileOptionBuilder.float_operation()\\r\\n ).with_empty_output().build())\\r\\n logger.info('------------------------------')\\r\\n logger.info(' Approximate Model Statistics ')\\r\\n logger.info('------------------------------')\\r\\n logger.info('FLOPS per input: {:,}'.format(flops.total_float_ops / self._batch_size))\\r\\n logger.info(\\r\\n 'Trainable Parameters: {:,}'.format(\\r\\n np.sum([np.prod(v.shape.as_list()) for v in tf.trainable_variables()])\\r\\n )\\r\\n )\\r\\n logger.info('------------------------------')\\r\\n\\r\\n # If there are any test data streams, build same model with different scope\\r\\n # Trainable parameters will be copied at test time\\r\\n if len(self._test_data) > 0:\\r\\n _build_datasource_summaries(self._test_data, mode='test')\\r\\n with tf.variable_scope('test'):\\r\\n _build_train_or_test(mode='test')\\r\\n logger.info('Built model for live testing.')\\r\\n\\r\\n if self._enable_live_testing:\\r\\n self._tester._post_model_build() # Create copy ops to be run before every test run\\r\",\n \"def construct(self):\\n self.input_size = self.numplanes * self.boardsize**2\\n \\n if self.hidden:\\n layers = [\\n torch.nn.Linear(self.input_size, self.hidden), \\n torch.nn.ReLU(),\\n torch.nn.Linear(self.hidden, self.boardsize**2)\\n ]\\n else:\\n layers = [torch.nn.Linear(self.input_size, self.boardsize**2)]\\n\\n self.layers = torch.nn.ModuleList(layers)\\n self.optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)\\n logging.info(\\\"Model initialized: %s\\\", self)\",\n \"def main():\\n g = CommanderGame([4, 3], 3)\\n g.fit_army_orders()\\n g.fit_game_matrix()\\n g.show_submatrixes([\\n [[4, 0, 0]],\\n [[2, 1, 0], [1, 1, 1]],\\n ])\\n print(f'Full game matrix: \\\\n{g.game_matrix_}')\",\n \"def process(self, mat):\",\n \"def main():\\n num_schedules = 150\\n trainer = AutoEncoderTrain(num_schedules)\\n trainer.train()\\n trainer.compute_mean()\\n trainer.create_iterables()\\n\\n trainer.round_each_encoding_and_create_array()\\n trainer.populate_a_matrix_per_schedule()\\n trainer.save_matrixes()\",\n \"def matrix_generation(self, matrix_size, generate_to):\\n matrix_A = np.random.randint(generate_to, size=(matrix_size, matrix_size))\\n matrix_B = np.random.randint(generate_to, size=(matrix_size, matrix_size))\\n # print(matrix_A)\\n # print(matrix_B)\\n # print(np.matmul(matrix_A, matrix_B))\\n matrices = (matrix_A, matrix_B)\\n return matrices\",\n \"def build_model(self):\\n import tensorflow as tf\\n \\n y = tf.nn.relu(tf.matmul(self.variables[\\\"input_observation\\\"], self.variables[\\\"W1\\\"]) + \\n self.variables[\\\"b1\\\"], name=\\\"y1\\\")\\n \\n for i in range(self.n_hidden-1):\\n y = tf.nn.relu(tf.matmul(y, self.variables[\\\"W\\\"+str(i+2)]) + \\n self.variables[\\\"b\\\"+str(i+2)], name=\\\"y\\\"+str(i+2))\\n \\n self.variables[\\\"y\\\"] = [tf.matmul(y, self.variables[\\\"Wo_0\\\"]) + self.variables[\\\"bo_0\\\"]]\\n for i in range(1, len(self.output_size)):\\n self.variables[\\\"y\\\"] += [tf.matmul(y, self.variables[\\\"Wo_%s\\\"%i]) + self.variables[\\\"bo_%s\\\"%i]]\",\n \"def compile(self):\\n m, n = self.input_shape[1], self.input_shape[2]\\n\\n inp = Input(shape=self.input_shape, traces=True)\\n self.add_layer(inp, \\\"DoG\\\")\\n\\n s1 = LIFNodes(shape=(18, m, n), traces=True)\\n self.add_layer(s1, \\\"conv_1\\\")\\n c1 = LIFNodes(shape=(18, m // 2, n // 2), traces=True)\\n self.add_layer(c1, \\\"pool_1\\\")\\n\\n s2 = LIFNodes(shape=(24, m // 2, n // 2), traces=True)\\n self.add_layer(s2, \\\"conv_2\\\")\\n c2 = LIFNodes(shape=(24, m // 4, n // 4), traces=True)\\n self.add_layer(c2, \\\"pool_2\\\")\\n\\n s3 = LIFNodes(shape=(32, m // 4, n // 4), traces=True)\\n self.add_layer(s3, \\\"conv_3\\\")\\n f = LIFNodes(shape=(32, 1), traces=True)\\n self.add_layer(f, \\\"global_pool\\\")\\n\\n conv1 = Conv2dConnection(inp, s1, 5, padding=2, weight_decay=0.01,\\n nu=0.01, update_rule=PostPre, decay=0.5)\\n self.add_connection(conv1, \\\"DoG\\\", \\\"conv_1\\\")\\n pool1 = MaxPool2dConnection(s1, c1, 2, 2, decay=0.5)\\n self.add_connection(pool1, \\\"conv_1\\\", \\\"pool_1\\\")\\n\\n conv2 = Conv2dConnection(c1, s2, 3, padding=1, weight_decay=0.01,\\n nu=0.01, update_rule=PostPre, decay=0.5)\\n self.add_connection(conv2, \\\"pool_1\\\", \\\"conv_2\\\")\\n pool2 = MaxPool2dConnection(s2, c2, 2, 2, decay=0.5)\\n self.add_connection(pool2, \\\"conv_2\\\", \\\"pool_2\\\")\\n\\n conv3 = Conv2dConnection(c2, s3, 3, padding=1, weight_decay=0.01,\\n nu=0.01, update_rule=PostPre, decay=0.5)\\n self.add_connection(conv3, \\\"pool_2\\\", \\\"conv_3\\\")\\n global_pool = MaxPool2dConnection(s3, f, (m // 4, n // 4), decay=0.5)\\n self.add_connection(global_pool, \\\"conv_3\\\", \\\"global_pool\\\")\\n\\n monitor = NetworkMonitor(self, layers=[\\\"DoG\\\", \\\"conv_1\\\", \\\"pool_1\\\",\\n \\\"conv_2\\\", \\\"pool_2\\\",\\n \\\"conv_3\\\", \\\"global_pool\\\"],\\n connections=[(\\\"DoG\\\", \\\"conv_1\\\"),\\n (\\\"pool_1\\\", \\\"conv_2\\\"),\\n (\\\"pool_2\\\", \\\"conv_3\\\")],\\n state_vars=[\\\"w\\\", \\\"s\\\"])\\n self.add_monitor(monitor, \\\"network_monitor\\\")\\n\\n return self\",\n \"def generateMatrix(self):\\n if self.tokenWeights and self.extraFeatures:\\n nFeatures = self.wordId + self.wordId2 + len(self.EXTRA_WEIGHTS_LABELS)\\n logging.info('Exporting TOKEN WEIGHTS AND EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n # iterate through 1st sentence\\n for wId, val in doc['s1'].iteritems():\\n mtrx[docId, wId] = val\\n # then iterate thru 2nd sentence, store on 2ND PARTITION\\n for wId, val in doc['s2'].iteritems():\\n mtrx[docId, self.wordId + wId] = val\\n # finally extra features values stored at the end of the vector\\n for label, val in doc['extraFeatures'].iteritems():\\n mtrx[docId, self.wordId + self.wordId2 + self.EXTRA_WEIGHTS_LABELS.index(label)] = val\\n\\n elif self.tokenWeights and not self.extraFeatures:\\n nFeatures = self.wordId + self.wordId2\\n logging.info('Exporting TOKEN WEIGHTS %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n # iterate through 1st sentence\\n for wId, val in doc['s1'].iteritems():\\n mtrx[docId, wId] = val\\n # then iterate thru 2nd sentence, store on 2ND PARTITION\\n for wId, val in doc['s2'].iteritems():\\n mtrx[docId, self.wordId + wId] = val\\n else:\\n nFeatures = len(self.EXTRA_WEIGHTS_LABELS)\\n logging.info('Exporting EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n for label, val in doc['extraFeatures'].iteritems():\\n mtrx[docId, self.EXTRA_WEIGHTS_LABELS.index(label)] = val\\n logging.info('Matrix generated')\\n logging.info(mtrx.shape)\\n return mtrx\",\n \"def _export_model(self):\\n graph = ComputeGraph.from_onnx(self.onnx_model.graph)\\n\\n print(\\\"Running constant propagation\\\")\\n constant_states = constant_propagation(graph)\\n\\n self._remove_constants(graph, constant_states)\\n self._remove_nops(graph, constant_states)\\n\\n # Add shape information from constant propagation:\\n for var, res in constant_states.items():\\n if var in graph.shape_dict:\\n shape = graph.shape_dict[var]\\n if res.shape != shape:\\n print(\\\"Warning: Shapes do not match: \\\", var, res.shape, shape)\\n if res.shape is not None:\\n print(\\\"Replacing shape {} with {}\\\".format(shape, res.shape))\\n graph.shape_dict[var] = res.shape\\n elif res.shape is not None:\\n graph.shape_dict[var] = res.shape\\n\\n print(\\\"Inference graph:\\\")\\n for node in graph.nodes:\\n inputs = node.inputs\\n input_shapes = (str(graph.shape_dict[i]) for i in node.inputs if i in graph.shape_dict)\\n outputs = node.outputs\\n output_shapes = (str(graph.shape_dict[o]) for o in node.outputs if o in graph.shape_dict)\\n print(\\\"{:<24} {:<20} {:<30} {:<30} {:<20} {:<30}\\\".format(node.name,\\n node.op_type,\\n \\\",\\\".join(inputs),\\n \\\",\\\".join(input_shapes),\\n \\\",\\\".join(outputs),\\n \\\",\\\".join(output_shapes)))\\n\\n memory_manager = MemoryManager()\\n\\n self._generate_weights_file(graph)\\n\\n self.dummy_input = generate_dummy_main(graph)\\n\\n self.reference_input = generate_reference_main(graph)\\n\\n self._generate_network_initialization(graph, memory_manager)\\n\\n self._generate_network_cleanup(graph, memory_manager)\\n\\n implementations = self._select_implementations(graph, memory_manager)\\n schedule = self._get_schedule(graph, implementations)\\n # self._print_live_ranges(schedule)\\n\\n input_names = [\\\"input_\\\"+name.replace('.', '_').replace(':', '_').replace('/', '_')\\n for name, type, shape in graph.inputs]\\n output_names = [\\\"output_\\\"+name.replace('.', '_').replace(':', '_').replace('/', '_')\\n for name, type, shape in graph.outputs]\\n\\n \\\"\\\"\\\"Currently we only allow single input (no batch processing) to the CNN, but this may be multi-channel input\\\"\\\"\\\"\\n inputs = graph.inputs\\n if len(inputs) > 1:\\n print(\\\"ERROR: Multiple inputs not supported!\\\")\\n exit(1)\\n else:\\n input_shape = graph.shape_dict[inputs[0].name]\\n print(\\\"Input shape: {}\\\".format(input_shape))\\n\\n if len(input_shape) == 4:\\n if input_shape[0] != 1:\\n print(\\\"ERROR: Inference for batch_size > 1 currently not supported!\\\")\\n exit(1)\\n\\n input_defs = [\\\"pico_cnn::naive::Tensor *\\\"+n for n in input_names]\\n\\n elif len(input_shape) == 3:\\n if input_shape[0] != 1:\\n print(\\\"ERROR: Inference for batch_size > 1 currently not supported!\\\")\\n exit(1)\\n\\n input_defs = [\\\"pico_cnn::naive::Tensor *\\\"+n for n in input_names]\\n\\n elif len(input_shape) == 2:\\n print(\\\"Input is one-dimensional (batch_size = 1 and num_input_channels = 1)\\\")\\n input_defs = [\\\"pico_cnn::naive::Tensor *\\\"+n for n in input_names]\\n\\n outputs = graph.outputs\\n if len(outputs) > 1:\\n print(\\\"ERROR: Multiple outputs not supported\\\")\\n exit(1)\\n else:\\n output_shape = graph.shape_dict[outputs[0].name]\\n print(\\\"Output shape: {}\\\".format(output_shape))\\n\\n if len(output_shape) == 2:\\n print(\\\"Output is one-dimensional (batch_size = 1 and num_input_channels = 1)\\\")\\n output_defs = [\\\"pico_cnn::naive::Tensor *\\\" + n for n in output_names]\\n elif len(output_shape) == 3:\\n print(\\\"ERROR: Unknown output shape of network: {}\\\".format(output_shape))\\n exit(1)\\n elif len(output_shape) == 4:\\n print(\\\"ERROR: Multi-dimensional output is currently not supported.\\\")\\n exit(1)\\n\\n network_def = \\\"void Network::run(\\\" + \\\", \\\".join(input_defs) + \\\", \\\" + \\\", \\\".join(output_defs) + \\\")\\\"\\n network_def_header = \\\"void run(\\\" + \\\", \\\".join(input_defs) + \\\", \\\" + \\\", \\\".join(output_defs) + \\\")\\\"\\n\\n layer_declaration_code = \\\"\\\"\\n layer_allocation_code = \\\"\\\"\\n layer_execution_code = \\\"\\\"\\n layer_deletion_code = \\\"\\\"\\n\\n \\\"\\\"\\\"Iterate over all tasks in the schedule, put some debug info in the code and the pico-cnn implementation.\\\"\\\"\\\"\\n for task in schedule:\\n num, node, impl = task\\n layer_allocation_code += \\\" //Layer \\\" + str(num) + \\\" \\\" + node.name + \\\" \\\" + node.op_type + \\\"\\\\n\\\"\\n layer_allocation_code += \\\" //Attributes\\\\n\\\"\\n for key, val in node.attrs.items():\\n layer_allocation_code += \\\" // \\\" + str(key) + \\\": \\\" + str(val) + \\\"\\\\n\\\"\\n layer_allocation_code += \\\" //Parameters\\\\n\\\"\\n layer_allocation_code += \\\" //Inputs: \\\" + \\\",\\\".join(node.inputs) + \\\"\\\\n\\\"\\n layer_allocation_code += \\\" //Outputs: \\\" + \\\",\\\".join(node.outputs) + \\\"\\\\n\\\"\\n layer_allocation_code += \\\" //Shape:\\\\n\\\"\\n for i in node.inputs:\\n layer_allocation_code += \\\" // {}: {}\\\\n\\\".format(i, graph.get_shape(i))\\n for o in node.outputs:\\n layer_allocation_code += \\\" // {}: {}\\\\n\\\".format(o, graph.get_shape(o))\\n\\n if impl:\\n layer_declaration_code += impl.generate_declaration()\\n layer_declaration_code += \\\"\\\\n\\\"\\n\\n layer_allocation_code += impl.generate_allocation()\\n layer_allocation_code += \\\"\\\\n\\\"\\n\\n layer_execution_code += impl.generate_execution()\\n layer_execution_code += \\\"\\\\n\\\"\\n\\n layer_deletion_code += impl.generate_deletion()\\n layer_deletion_code += \\\"\\\\n\\\"\\n\\n else:\\n print(\\\"ERROR: Unsupported layer: {}! Aborting code generation.\\\".format(node.op_type))\\n return 1\\n\\n self.constructor_code += layer_allocation_code + \\\"\\\\n\\\"\\n self.destructor_code += layer_deletion_code + \\\"\\\\n\\\"\\n\\n # # TODO: What does this loop do?\\n # for id, buffer in memory_manager.buffers.items():\\n # if graph.is_tensor(id):\\n # continue\\n # if graph.is_input(id):\\n # continue\\n # if graph.is_output(id):\\n # continue\\n\\n network_code: Text = \\\"#include \\\\\\\"network.h\\\\\\\"\\\\n\\\\n\\\"\\n network_code += \\\"Network::Network() {\\\\n\\\\n\\\"\\n network_code += self.constructor_code + \\\"\\\\n\\\"\\n network_code += \\\"}\\\\n\\\\n\\\"\\n network_code += \\\"Network::~Network() {\\\\n\\\"\\n network_code += self.destructor_code + \\\"\\\\n\\\"\\n network_code += \\\"}\\\\n\\\\n\\\"\\n network_code += network_def+\\\"{\\\\n\\\"\\n network_code += layer_execution_code\\n\\n network_code += \\\"}\\\\n\\\\n\\\"\\n\\n network_header = \\\"#ifndef NETWORK_H\\\\n\\\"\\n network_header += \\\"#define NETWORK_H\\\\n\\\\n\\\"\\n network_header += \\\"#include \\\\\\\"pico-cnn/pico-cnn.h\\\\\\\"\\\\n\\\\n\\\"\\n network_header += \\\"class Network {\\\\n\\\"\\n network_header += \\\"public:\\\\n\\\"\\n network_header += \\\"Network();\\\\n\\\"\\n network_header += \\\"~Network();\\\\n\\\"\\n network_header += network_def_header + \\\"; \\\\n\\\\n\\\"\\n network_header += self.buffer_declaration + \\\"\\\\n\\\"\\n network_header += layer_declaration_code\\n network_header += \\\"};\\\\n\\\"\\n network_header += \\\"#endif //NETWORK_H\\\\n\\\"\\n\\n self.network_code = network_code\\n self.network_header = network_header\\n\\n \\\"\\\"\\\"\\n Create Makefile containing a target for the generated dummy input and a network specific one.\\n The code for the network specific input has to be written manually.\\n \\\"\\\"\\\"\\n # TODO: Does this need to be more sophisticated?\\n self.makefile = \\\"CC = g++\\\\n\\\"\\n self.makefile += \\\"CFLAGS = -std=c++11 -Wall -O2 -march=native -DINFO\\\\n\\\"\\n self.makefile += \\\"LDFLAGS = -L../../../pico-cnn\\\\n\\\"\\n self.makefile += \\\"LD_LIBS = -lpico-cnn -lm\\\\n\\\\n\\\"\\n self.makefile += \\\"# list of all generated .cpp files.\\\\n\\\"\\n self.makefile += \\\"NETWORK_LIST = network.cpp\\\"\\n self.makefile += \\\"\\\\n\\\\ndummy_input: dummy_input.cpp $(NETWORK_LIST) libpico-cnn.a\\\\n\\\\t\\\"\\n self.makefile += \\\"$(CC) dummy_input.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) $(LDFLAGS) $(LD_LIBS) -o dummy_input\\\"\\n self.makefile += \\\"\\\\n\\\\nreference_input: reference_input.cpp $(NETWORK_LIST) libpico-cnn.a\\\\n\\\\t\\\"\\n self.makefile += \\\"$(CC) reference_input.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) \\\" \\\\\\n \\\"$(LDFLAGS) $(LD_LIBS) -o reference_input\\\"\\n self.makefile += \\\"\\\\n\\\\n{}: {}.cpp $(NETWORK_LIST) libpico-cnn.a\\\\n\\\\t\\\".format(self.model_name, self.model_name)\\n self.makefile += \\\"$(CC) {}.cpp $(NETWORK_LIST) -I../../.. $(CFLAGS) \\\" \\\\\\n \\\"$(LDFLAGS) $(LD_LIBS) -o {}\\\".format(self.model_name, self.model_name)\\n self.makefile += \\\"\\\\n\\\\nall: dummy_input reference_input {}\\\".format(self.model_name)\\n self.makefile += \\\"\\\\n\\\\n.PHONY: clean\\\\n\\\"\\n self.makefile += \\\"clean:\\\\n\\\\trm -rf {} dummy_input reference_input\\\\n\\\".format(self.model_name)\\n self.makefile += \\\"\\\\n\\\\n.PHONY: libpico-cnn.a\\\\n\\\"\\n self.makefile += \\\"libpico-cnn.a:\\\\n\\\\t$(MAKE) -C ../../../pico-cnn\\\"\\n\\n self.save(\\\"./generated_code/{}\\\".format(self.model_name))\",\n \"def create_start_data(self):\\n\\t\\tdef inputMesh(feature_size):\\n\\t\\t\\tc1= np.expand_dims(np.array([0,-0.9]),0)\\n\\t\\t\\tc2= np.expand_dims(np.array([-0.9,0.9]),0)\\n\\t\\t\\tc3= np.expand_dims(np.array([0.9,0.9]),0)\\n\\t\\t\\tx1 = np.expand_dims(np.pad(np.array([0,-0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\\n\\t\\t\\tx2 = np.expand_dims(np.pad(np.array([-0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\\n\\t\\t\\tx3 = np.expand_dims(np.pad(np.array([0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\\n\\t\\t\\tedge_index = np.transpose(np.array([[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]])) # COO format\\n\\t\\t\\treturn np.concatenate((c1,c2,c3),axis=0), np.concatenate((x1,x2,x3),axis=0),edge_index\\n\\n\\t\\tc, x, edge_index = inputMesh(self.params.feature_size)# x is c with zeros appended, x=f ..pixel2mesh\\n\\t\\tdata_list_x = []\\n\\t\\tdata_list_c = []\\n\\t\\tdata_list_pid = []\\n\\t\\tfor i in range(self.params.batch_size):\\n\\t\\t\\tdata_list_x.append(Data(x=torch.Tensor(x).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\\n\\t\\t\\tdata_list_c.append(Data(x=torch.Tensor(c).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\\n\\t\\t\\tdata_list_pid.append(Data(x=torch.zeros(c.shape[0],1).type(dtypeL).requires_grad_(False)))\\n\\t\\tbatch_x = Batch.from_data_list(data_list_x)\\n\\t\\tbatch_c = Batch.from_data_list(data_list_c)\\n\\t\\tbatch_pid = Batch.from_data_list(data_list_pid)\\n\\t\\treturn batch_x, batch_c, batch_pid\",\n \"def create_modules(self):\\n self.bitcell = self.replica_bitcell = self.mod_replica_bitcell()\\n self.add_mod(self.bitcell)\\n\\n # This is the replica bitline load column that is the height of our array\\n self.rbl = bitcell_array(name=\\\"bitline_load\\\", cols=1, rows=self.bitcell_loads)\\n self.add_mod(self.rbl)\\n\\n # FIXME: The FO and depth of this should be tuned\\n self.delay_chain = self.mod_delay_chain([self.delay_fanout]*self.delay_stages)\\n self.add_mod(self.delay_chain)\\n\\n self.inv = pinv()\\n self.add_mod(self.inv)\\n\\n self.access_tx = ptx(tx_type=\\\"pmos\\\")\\n self.add_mod(self.access_tx)\",\n \"def run(layers):\",\n \"def process(self):\\n # Opening and preprocessing of the input file\\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\\n if self.options.mbtiles_fromdisk:\\n i_parm=10\\n if self.options.mbtiles_todisk:\\n i_parm=11\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :mbtiles from/to disk [\\\",i_parm,\\\"] mbtiles_fromdisk[\\\",self.options.mbtiles_fromdisk,\\\"] mbtiles_todisk[\\\",self.options.mbtiles_todisk,\\\"]\\\"\\n self.mbtiles_setup(i_parm)\\n return\\n else:\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :tile creation mbtiles[\\\",self.options.mbtiles,\\\"]\\\"\\n self.open_input()\\n # Generation of main metadata files and HTML viewers\\n self.generate_metadata()\\n # Generation of the lowest tiles\\n self.generate_base_tiles()\\n # Generation of the overview tiles (higher in the pyramid)\\n self.generate_overview_tiles()\\n # Generating of KML\\n self.generate_kml()\",\n \"def CreateDesignMatrix_X(z, x, y, n ):\\n if len(x.shape) > 1:\\n x = np.ravel(x)\\n y = np.ravel(y)\\n\\n N = len(x)\\n l = int((n+1)*(n+2)/2) \\n X = np.ones((N,l))\\n\\n for i in range(1,n+1):\\n q = int((i)*(i+1)/2)\\n for k in range(i+1):\\n X[:,q+k] = x**(i-k) * y**k\\n \\n X, z_, indicies = shuffle(X, z)\\n X_train, X_test, z_train, z_test = train_test_split(X, z_, test_size=split_train_test, random_state=seed, shuffle=False)\\n X_test, X_val, z_test, z_val = train_test_split(X_test, z_test, test_size=split_test_val, random_state=seed, shuffle=False)\\n\\n return X, X_train, X_test, X_val, z_train, z_test, z_val, indicies\",\n \"def _setup(self) -> None:\\n #TODO: type\\n self.activation = self.params['activation']\\n\\n self.batchsize: int = self.params['batchsize']\\n\\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\\n\\n self.d: int = self.input_shape[1]\\n assert(not self.d == 0)\\n\\n self.n: int = int(sqrt(self.input_shape[2]))\\n assert(not self.n == 0)\\n\\n self.dtype: type = self.params['dtype']\\n\\n # initialize weights\\n self.W: List[tf.Tensor] = []\\n \\n for i in range(3):\\n #TODO: type\\n w_init = self.params['initializer_w']\\n if self.params['initializer_w' + str(i)] is not None:\\n w_init = self.params['initializer_w' + str(i)]\\n\\n w_stddev: float = self.params['stddev_w']\\n if self.params['stddev_w' + str(i)] is not None:\\n w_stddev = self.params['stddev_w' + str(i)]\\n\\n self.W.append(tf.get_variable(\\\"weights_\\\" + str(i),\\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\\n dtype = self.dtype,\\n initializer = w_init(stddev=w_stddev)))\\n\\n #TODO: type\\n b_init = self.params['initializer_b']\\n b_stddev = self.params['stddev_b']\\n self.B: tf.Tensor = tf.get_variable(\\\"biases\\\", shape = (1, self.d, 1),\\n dtype = self.dtype,\\n initializer = b_init(stddev=b_stddev))\\n\\n # create/load expand matrix\\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\\n self.expand: tf.Tensor = tf.get_variable(\\n \\\"expand\\\" + str(self.n),\\n shape = (self.n, self.n * self.n),\\n dtype = self.dtype,\\n initializer = tf.constant_initializer(make_expand(self.n)))\\n\\n # create/load tile matrix\\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\\n for i in range(1, self.n):\\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\\n\\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)\",\n \"def generate_map(self):\\n\\n # Create main streets first\\n self.create_main_streets()\\n\\n # Then create the commercial buildings in the center of town\\n self.create_commercial_center()\\n\\n # Then create the neighborhoods that populate the rest of the city\\n while(self.create_neighborhood()):\\n pass\\n\\n # Clean up any invalid buildings that were created\\n self.delete_inaccessible_buildings()\",\n \"def build(self):\\n if self.is_built:\\n return\\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n\\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\\n assert self.nelements > 0, 'nelements=%s' % self.nelements\\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\\n #self.names = []\\n self.nelements //= self.ntimes\\n\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n self.node_element = np.zeros((self.ntotal, 2), dtype=idtype)\\n #oxx, oyy, txy, angle, major, minor, ovm\\n self.data = np.zeros((self.ntimes, self.nelements, 8), dtype=fdtype)\\n self.location = np.empty(self.ntotal, dtype='U8')\\n\\n self._times = np.zeros(self.ntimes, dtype=dtype)\",\n \"def create_grids(self):\\n \\n par = self.par\\n\\n # a. retirement\\n \\n # pre-decision states\\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\\n \\n # post-decision states\\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\\n \\n # b. working: state space (m,n,k) \\n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\\n\\n par.Nn = par.Nm\\n par.n_max = par.m_max + par.n_add\\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\\n\\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\\n\\n # c. working: w interpolant (and wa and wb and wq)\\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\\n par.a_max = par.m_max + par.a_add\\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\\n \\n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\\n par.b_max = par.n_max + par.b_add\\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\\n \\n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\\n \\n # d. working: egm (seperate grids for each segment)\\n \\n if par.solmethod == 'G2EGM':\\n\\n # i. dcon\\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\\n \\n # ii. acon\\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\\n par.a_acon = np.zeros(par.grid_b_acon.shape)\\n par.b_acon = par.grid_b_acon\\n\\n # iii. con\\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\\n \\n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\\n\\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\\n par.a_con = np.zeros(par.c_con.shape)\\n par.d_con = np.zeros(par.c_con.shape)\\n \\n elif par.solmethod == 'NEGM':\\n\\n par.grid_l = par.grid_m\\n\\n # e. shocks\\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\\n\\n if par.Neta > 1:\\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\\n else:\\n par.eta = np.ones(1)\\n par.w_eta = np.ones(1)\\n\\n # f. timings\\n par.time_work = np.zeros(par.T)\\n par.time_w = np.zeros(par.T)\\n par.time_egm = np.zeros(par.T)\\n par.time_vfi = np.zeros(par.T)\",\n \"def test_matrix_shapes(self):\\n k = [2, 3, 4, 5, 6]\\n mn = self.create_chain_model(k)\\n\\n max_states = max(k)\\n\\n assert mn.matrix_mode is False, \\\"Matrix mode flag was set prematurely\\\"\\n\\n mn.create_matrices()\\n\\n assert mn.matrix_mode, \\\"Matrix mode flag wasn't set correctly\\\"\\n\\n assert mn.unary_mat.shape == (max_states, 5)\",\n \"def get_all_coding_matrices(self):\\n class tran_matrix():\\n def __init__(self):\\n self.S = None\\n self.T = None\\n self.H1 = None\\n self.H2 = None\\n self.G1 = None\\n self.G2 = None\\n self.H = None\\n self.H2G2 = None\\n\\n def __init__(self, S, T, H1, H2, G1, G2, H, H2G2):\\n self.S = S\\n self.T = T\\n self.H1 = H1\\n self.H2 = H2\\n self.G1 = G1\\n self.G2 = G2\\n self.H = H\\n self.H2G2 = H2G2\\n\\n s = self.sources\\n s_edges = [self.out_edges(x) for x in s]\\n S = [list(set(self.get_edges_indices(src))) for src in s_edges]\\n\\n matrices = []\\n for dsts in self.dst_evolution_rec[::-1]:\\n T = [sorted(x) for x in dsts]\\n H2_raw = self.coding_matrix[T[0]].ix[S[1]].values\\n G2_raw = self.coding_matrix[T[1]].ix[S[1]].values\\n H1 = numpy_to_generic(self.coding_matrix[T[0]].ix[S[0]].values)\\n H2 = numpy_to_generic(H2_raw)\\n G1 = numpy_to_generic(self.coding_matrix[T[1]].ix[S[0]].values)\\n G2 = numpy_to_generic(G2_raw)\\n H = numpy_to_generic(self.coding_matrix[T[0]].values)\\n H2G2 = numpy_to_generic(np.hstack((H2_raw, G2_raw)))\\n temp = tran_matrix(S, T, H1, H2, G1, G2, H, H2G2)\\n matrices.append(temp)\\n\\n return matrices\",\n \"def __set_transform_matrices(self):\\n self.tf_matrices_list = []\\n\\n transform_matrix = eye(4) # creates a unit matrix via passing argument.\\n for i in range(self.joint_count):\\n transform_matrix = transform_matrix * self.__create_tf_matrix(self.alpha[i], self.a[i], self.d[i], self.q[i]).subs(self.dh_params)\\n self.tf_matrices_list.append(transform_matrix)\",\n \"def main(self):\\n if self.mode==0: #drawing\\n self.draw()\\n self.graph_drawing=self.cleanGraph(self.graph_drawing)\\n #if len(self.graph_drawing)>1:\\n # self.function_interpolation=self.polynomialInterpolation2D(self.graph_drawing,1)\\n # self.graph_interpolation=self.sample(self.function_interpolation,len(self.graph_drawing))\\n elif self.mode==1: #construction\\n self.step+=1\\n self.time=self.step/self.max_step\\n if self.step>self.max_step:\\n self.mode=2\\n #self.graph_construction=self.discreteComplexComposeGraph(self.coefficients,self.time) #complex now\\n self.graph_construction=self.numpyComposeConstructionGraph(self.coefficients,t=self.time)\\n self.vectors=self.getVectors([(0,0)]+self.graph_construction)\\n self.graph_display.append(self.graph_construction[-1])\\n\\n elif self.mode==2:\\n self.draw()\",\n \"def assemble_matrices(self):\\n \\n #Pointer reassignment for convenience\\n N = self.ngrids\\n\\n #Begin with a linked-list data structure for the transmissibilities,\\n #and one-dimenstional arrays for the diagonal of B and the flux vector\\n T = lil_matrix((N, N), dtype=np.double)\\n B = np.zeros(N, dtype=np.double)\\n Q = np.zeros(N, dtype=np.double)\\n\\n #Read in boundary condition types and values\\n bcs = self.input_data['boundary conditions']\\n bc_type_1 = bcs['left']['type'].lower()\\n bc_type_2 = bcs['right']['type'].lower()\\n bc_value_1 = bcs['left']['value']\\n bc_value_2 = bcs['right']['value']\\n \\n #Loop over all grid cells\\n for i in range(N):\\n\\n #Apply left BC\\n if i == 0:\\n T[i, i+1] = -self.compute_transmissibility(i, i + 1)\\n\\n if bc_type_1 == 'neumann':\\n T[i, i] = T[i,i] - T[i, i+1]\\n elif bc_type_1 == 'dirichlet':\\n #Computes the transmissibility of the ith block\\n T0 = self.compute_transmissibility(i, i)\\n T[i, i] = T[i,i] - T[i, i+1] + 2.0 * T0\\n Q[i] = 2.0 * T0 * bc_value_1\\n else:\\n pass #TODO: Add error checking here if no bc is specified\\n\\n #Apply right BC\\n elif i == (N - 1):\\n T[i, i-1] = -self.compute_transmissibility(i, i - 1)\\n\\n if bc_type_2 == 'neumann':\\n T[i, i] = T[i,i] - T[i, i-1]\\n elif bc_type_2 == 'dirichlet':\\n #Computes the transmissibility of the ith block\\n T0 = self.compute_transmissibility(i, i)\\n T[i, i] = T[i, i] - T[i, i-1] + 2.0 * T0\\n Q[i] = 2.0 * T0 * bc_value_2\\n else:\\n pass #TODO:Add error checking here if no bc is specified\\n\\n #If there is no boundary condition compute interblock transmissibilties\\n else:\\n T[i, i-1] = -self.compute_transmissibility(i, i-1)\\n T[i, i+1] = -self.compute_transmissibility(i, i+1)\\n T[i, i] = (self.compute_transmissibility(i, i-1) +\\n self.compute_transmissibility(i, i+1))\\n\\n #Compute accumulations\\n B[i] = self.compute_accumulation(i)\\n\\n #If constant-rate wells are present, add them to the flux vector\\n if self.rate_well_grids is not None:\\n Q[self.rate_well_grids] += self.rate_well_values\\n\\n \\n #Return sparse data-structures\\n return (T.tocsr(), \\n csr_matrix((B, (np.arange(N), np.arange(N))), shape=(N,N)), \\n Q)\",\n \"def run(self):\\n super().run()\\n # more verbose creation date for clarity\\n creation_date = f'20{self.creation_date}'\\n make_e3sm_to_cmip_maps(self.config, self.logger, self.mesh_short_name,\\n creation_date, self.ntasks)\",\n \"def build(self, input_shape):\\n\\n # get shape of input matrix x\\n self.num_of_vertices = input_shape[1]\\n self.num_of_features = input_shape[2]\\n self.num_of_timesteps = input_shape[3]\\n #self.W_1.shape = (num_of_timesteps,)\\n #self.W_2.shape = (num_of_features, num_of_timesteps)\\n #self.W_3.shape = (num_of_features,)\\n #self.b_s.shape = (1, num_of_vertices, num_of_vertices)\\n #self.V_s.shape = (num_of_vertices, num_of_vertices)\\n\\n self.w1 = self.add_weight(name='w1', shape=(self.num_of_timesteps, ),\\n initializer='glorot_normal', trainable=True)\\n self.w2 = self.add_weight(name='w2', shape=(self.num_of_features, self.num_of_timesteps),\\n initializer='glorot_normal', trainable=True)\\n self.w3 = self.add_weight(name='w3', shape=(self.num_of_features,),\\n initializer='glorot_normal', trainable=True)\\n self.b = self.add_weight(name='b', shape=(1, self.num_of_vertices, self.num_of_vertices),\\n initializer='zeros', trainable=True)\\n self.v = self.add_weight(name='v', shape=(self.num_of_vertices, self.num_of_vertices),\\n initializer='glorot_normal', trainable=True)\\n\\n super(Spatial_Attention_layer, self).build(input_shape)\",\n \"def model(inputs):\\n outputs = {}\\n\\n # First, build the encoder\\n encoder_fn = _get_network(params.encoder_name)\\n with tf.variable_scope('encoder', reuse=reuse):\\n # Produces id/pose units\\n enc_outputs = encoder_fn(inputs['images_1'], params, is_training)\\n outputs['ids_1'] = enc_outputs['ids']\\n\\n # Second, build the decoder and projector\\n decoder_fn = _get_network(params.decoder_name)\\n with tf.variable_scope('decoder', reuse=reuse):\\n outputs['voxels_1'] = decoder_fn(outputs['ids_1'], params, is_training)\\n if run_projection:\\n projector_fn = _get_network(params.projector_name)\\n with tf.variable_scope('projector', reuse=reuse):\\n outputs['projs_1'] = projector_fn(\\n outputs['voxels_1'], inputs['matrix_1'], params, is_training)\\n # Infer the ground-truth mask\\n with tf.variable_scope('oracle', reuse=reuse):\\n outputs['masks_1'] = projector_fn(inputs['voxels'], inputs['matrix_1'],\\n params, False)\\n\\n # Third, build the entire graph (bundled strategy described in PTN paper)\\n for k in range(1, params.step_size):\\n with tf.variable_scope('projector', reuse=True):\\n outputs['projs_%d' % (k + 1)] = projector_fn(\\n outputs['voxels_1'], inputs['matrix_%d' %\\n (k + 1)], params, is_training)\\n with tf.variable_scope('oracle', reuse=True):\\n outputs['masks_%d' % (k + 1)] = projector_fn(\\n inputs['voxels'], inputs['matrix_%d' % (k + 1)], params, False)\\n\\n return outputs\",\n \"def generate(self, n_enemies, n_blocks):\\n self.create_map()\\n self.create_floor()\\n self.player = self.create_player_at(0, 0)\\n self.create_dummy_obj_at(0, 1)\\n self.create_dummy_obj_at(1, 0)\\n self.create_soft_block_at(0, 2)\\n self.create_soft_block_at(2, 0)\\n self.create_hard_blocks() \\n self.create_enemies(n_enemies)\\n self.create_soft_blocks(n_blocks) \\n self.clear_dummy_obj()\",\n \"def build(self, input_shape):\\n\\n # get shape of input matrix x\\n num_of_vertices = input_shape[1]\\n num_of_features = input_shape[2]\\n num_of_timesteps = input_shape[3]\\n #self.U_1.shape = (num_of_vertices,)\\n #self.U_2.shape = (num_of_features, num_of_vertices)\\n #self.U_3.shape = (num_of_features,)\\n #self.b_e.shape = (1, num_of_timesteps, num_of_timesteps)\\n #self.V_e.shape = (num_of_timesteps, num_of_timesteps)\\n\\n self.u1 = self.add_weight(name='u1', shape=(num_of_vertices, ),\\n initializer='glorot_normal', trainable=True)\\n self.u2 = self.add_weight(name='u2', shape=(num_of_features, num_of_vertices),\\n initializer='glorot_normal', trainable=True)\\n self.u3 = self.add_weight(name='u3', shape=(num_of_features,),\\n initializer='glorot_normal', trainable=True)\\n self.b = self.add_weight(name='b', shape=(1, num_of_timesteps, num_of_timesteps),\\n initializer='zeros', trainable=True)\\n self.v = self.add_weight(name='v', shape=(num_of_timesteps, num_of_timesteps),\\n initializer='glorot_normal', trainable=True)\\n\\n super(Temporal_Attention_layer, self).build(input_shape)\",\n \"def synthetic_gen(self):\\r\\n logging.debug('generating synthetic map...')\\r\\n data = self.realData\\r\\n unit = Params.unitGrid\\r\\n x_min = np.floor(Params.LOW[0] / unit) * unit\\r\\n x_max = np.ceil(Params.HIGH[0] / unit) * unit\\r\\n y_min = np.floor(Params.LOW[1] / unit) * unit\\r\\n y_max = np.ceil(Params.HIGH[1] / unit) * unit\\r\\n\\r\\n x_CELL = int(np.rint((x_max - x_min) / unit))\\r\\n y_CELL = int(np.rint((y_max - y_min) / unit))\\r\\n\\r\\n self.root.n_box = np.array([[x_min, y_min], [x_max, y_max]])\\r\\n\\r\\n self.mapp = np.zeros((x_CELL, y_CELL)) - 1 # ## initialize every cell with -1\\r\\n for i in range(Params.NDATA): # ## populate the map\\r\\n point = data[:, i]\\r\\n cell_x = int(np.floor((point[0] - x_min) / unit))\\r\\n cell_y = int(np.floor((point[1] - y_min) / unit))\\r\\n if self.mapp[cell_x, cell_y] != -1:\\r\\n self.mapp[cell_x, cell_y] += 1\\r\\n else:\\r\\n self.mapp[cell_x, cell_y] = 1\\r\\n\\r\\n for i in range(x_CELL): # ## perturb the counts\\r\\n for j in range(y_CELL):\\r\\n if self.mapp[i, j] != -1:\\r\\n self.mapp[i, j] += np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\\r\\n else:\\r\\n self.mapp[i, j] = np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\\r\\n # if noisy count is negative, ignore the noise and generate no points\\r\\n if self.mapp[i, j] < 0:\\r\\n self.mapp[i, j] = 0\",\n \"def _generate_weighted_matrices(self):\\n self.degree_weighted_matrices = dict()\\n mes = []\\n args = []\\n for metaedge, matrix in self.adj_matrices.items():\\n mes.append(metaedge)\\n args.append({'matrix': matrix, 'w': self.w, 'degree_fwd': self.out_degree[metaedge],\\n 'degree_rev': self.in_degree[metaedge]})\\n res = parallel_process(array=args, function=mt.weight_by_degree, use_kwargs=True, n_jobs=self.n_jobs,\\n front_num=0)\\n for metaedge, matrix in zip(mes, res):\\n self.degree_weighted_matrices[metaedge] = matrix\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6533795","0.6478307","0.6406922","0.62815374","0.6245266","0.6195874","0.6190174","0.6190174","0.61767757","0.61684704","0.6142635","0.61235183","0.60565335","0.60293376","0.5989289","0.59723383","0.5916607","0.59163237","0.59031653","0.59013414","0.589474","0.5886261","0.58808684","0.58790284","0.5870848","0.5870637","0.5865471","0.58637863","0.5860027","0.5840572","0.5839574","0.5807056","0.5791943","0.57752836","0.5771355","0.57705003","0.5764979","0.57604486","0.57393616","0.57390124","0.57335967","0.57335967","0.5732024","0.57265544","0.5724135","0.5718383","0.5714655","0.5700298","0.56991017","0.5693946","0.56834745","0.5681698","0.56806767","0.56719494","0.56709474","0.56699455","0.56531245","0.5639014","0.56350243","0.5628859","0.562157","0.56085956","0.56029636","0.5587023","0.55860645","0.55834824","0.5577973","0.55671835","0.5561125","0.55526835","0.55434257","0.5536904","0.5529424","0.5520656","0.55198824","0.5509883","0.55087745","0.550725","0.5506311","0.55010056","0.5498075","0.54964983","0.5495398","0.54936755","0.54855347","0.5485139","0.5483914","0.5483829","0.5483806","0.54785085","0.5472424","0.5467047","0.5464701","0.5458236","0.54539","0.5450642","0.54505014","0.54490215","0.5446259","0.54460394"],"string":"[\n \"0.6533795\",\n \"0.6478307\",\n \"0.6406922\",\n \"0.62815374\",\n \"0.6245266\",\n \"0.6195874\",\n \"0.6190174\",\n \"0.6190174\",\n \"0.61767757\",\n \"0.61684704\",\n \"0.6142635\",\n \"0.61235183\",\n \"0.60565335\",\n \"0.60293376\",\n \"0.5989289\",\n \"0.59723383\",\n \"0.5916607\",\n \"0.59163237\",\n \"0.59031653\",\n \"0.59013414\",\n \"0.589474\",\n \"0.5886261\",\n \"0.58808684\",\n \"0.58790284\",\n \"0.5870848\",\n \"0.5870637\",\n \"0.5865471\",\n \"0.58637863\",\n \"0.5860027\",\n \"0.5840572\",\n \"0.5839574\",\n \"0.5807056\",\n \"0.5791943\",\n \"0.57752836\",\n \"0.5771355\",\n \"0.57705003\",\n \"0.5764979\",\n \"0.57604486\",\n \"0.57393616\",\n \"0.57390124\",\n \"0.57335967\",\n \"0.57335967\",\n \"0.5732024\",\n \"0.57265544\",\n \"0.5724135\",\n \"0.5718383\",\n \"0.5714655\",\n \"0.5700298\",\n \"0.56991017\",\n \"0.5693946\",\n \"0.56834745\",\n \"0.5681698\",\n \"0.56806767\",\n \"0.56719494\",\n \"0.56709474\",\n \"0.56699455\",\n \"0.56531245\",\n \"0.5639014\",\n \"0.56350243\",\n \"0.5628859\",\n \"0.562157\",\n \"0.56085956\",\n \"0.56029636\",\n \"0.5587023\",\n \"0.55860645\",\n \"0.55834824\",\n \"0.5577973\",\n \"0.55671835\",\n \"0.5561125\",\n \"0.55526835\",\n \"0.55434257\",\n \"0.5536904\",\n \"0.5529424\",\n \"0.5520656\",\n \"0.55198824\",\n \"0.5509883\",\n \"0.55087745\",\n \"0.550725\",\n \"0.5506311\",\n \"0.55010056\",\n \"0.5498075\",\n \"0.54964983\",\n \"0.5495398\",\n \"0.54936755\",\n \"0.54855347\",\n \"0.5485139\",\n \"0.5483914\",\n \"0.5483829\",\n \"0.5483806\",\n \"0.54785085\",\n \"0.5472424\",\n \"0.5467047\",\n \"0.5464701\",\n \"0.5458236\",\n \"0.54539\",\n \"0.5450642\",\n \"0.54505014\",\n \"0.54490215\",\n \"0.5446259\",\n \"0.54460394\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5499406"},"document_rank":{"kind":"string","value":"80"}}},{"rowIdx":82999,"cells":{"query":{"kind":"string","value":"Forward pass of the bidirectional hidden states."},"document":{"kind":"string","value":"def forward(self, output):\n \n last_ht, output_fw_intermediate, output_bw_intermediate = self.extract_hidden_states(output)\n \n # Intermediate hidden state internal processing\n output_reduced_fw = self.implement_processing(output_fw_intermediate, self.processing_fw)\n output_reduced_bw = self.implement_processing(output_bw_intermediate, self.processing_bw, forward = False)\n \n # Concatenation of intermediate hidden state outputs\n output_reduced = torch.cat((output_reduced_fw, output_reduced_bw),-1)\n \n # Reduction of concatenated outputs dimension to match last hidden state\n intermediate_ht = torch.matmul(output_reduced, self.compression)\n \n # Last hidden state internal processing\n last_ht = torch.matmul(last_ht, self.processing_last_ht)\n last_ht = (1-torch.tensor(self.weight))*last_ht\n \n # Weighted sum of hidden states\n ht = last_ht.add(intermediate_ht)\n \n return ht"},"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 _bridge_bidirectional_hidden(self, hidden):\n num_layers = hidden.size(0) // 2\n _, batch_size, hidden_size = hidden.size()\n return hidden.view(num_layers, 2, batch_size, hidden_size)\\\n .transpose(1, 2).contiguous().view(num_layers, batch_size, hidden_size * 2)","def forward(self, states):\n raise NotImplementedError()","def init_hidden(self, batch_size):\r\n \r\n self.hidden_state = (\r\n torch.zeros(((1+self.bidirectional)*self.num_layers,\r\n batch_size,\r\n self.hidden_size)).to(self.device),\r\n torch.zeros(((1+self.bidirectional)*self.num_layers, \r\n batch_size, \r\n self.hidden_size)).to(self.device))","def toggle_hidden(self):\n AbstractChild.toggle_hidden(self)\n self.accFrame.update_values()\n self.botFrame.update_values()\n # On toggle hidden\n self.on_toggle_hidden()","def hidden(self):\n return self._hidden","def forward(self, node_hidden, edge_hidden, adj_matrix, mask):\n # x.shape = (batch, max_length, d_atom)\n node_hidden = self.dropout(self.norm(node_hidden))\n node_hidden_first, edge_hidden_temp = self.self_attn(node_hidden, node_hidden, edge_hidden, adj_matrix, mask)\n # the first residue block\n node_hidden_first = node_hidden + self.dropout(self.norm(node_hidden_first))\n node_hidden_second = self.feed_forward(node_hidden_first)\n # the second residue block\n return node_hidden + node_hidden_first + self.dropout(self.norm(node_hidden_second)), edge_hidden","def hidden(self, hidden):\n\n self._hidden = hidden","def forward(self, input, states):\n (hidden, cell) = states\n\n input = input + self.transform(hidden)\n\n forget_gate = torch.sigmoid(self.forget(input))\n input_gate = torch.sigmoid(self.input(input))\n output_gate = torch.sigmoid(self.output(input))\n state_gate = torch.tanh(self.state(input))\n\n # Update internal cell state\n cell = forget_gate * cell + input_gate * state_gate\n hidden = output_gate * torch.tanh(cell)\n\n return hidden, cell","def _transit_state(self) -> None:\n pass","def _TransformHidden(self, _):\n raise NotImplementedError()","def extract_hidden_states(self, output):\n \n # Extracting the forward and backward hidden states from the last BiLSTM layer\n # output (batch_size, sequence length, 2 * hidden dim)\n output_fw = output[:,:,0:self._hidden_size]\n output_bw = output[:,:,self._hidden_size:]\n \n hidden_states = torch.cat((output_fw, output_bw),-1)\n \n return hidden_states","def forward(self, input, hidden_states):\n h, c = self.ih2h(input, hidden_states[0])\n next_hiddens = [(h, c)]\n h, c = self.h2h(h, hidden_states[1])\n next_hiddens.append((h, c))\n output = self.log_softmax(self.h2o(h))\n return output, next_hiddens","def forward(self, hidden: Union[torch.Tensor, Tuple[torch.Tensor, ...]]) -> Union[torch.Tensor, Tuple[torch.Tensor, ...]]:\n # First, map the non-tuple version to a 1-tuple for easier processing.\n # We will undo this at the end\n if not isinstance(hidden, tuple):\n hidden = (hidden,)\n\n batch_size, hidden_size = hidden[0].size()\n\n # If we are going to share parameters across the forward and backward\n # directions, then we need to separate them in the tensors\n if self.share_bidirectional_parameters:\n # shape: (batch_size, 2, encoder_hidden_size // 2)\n hidden = tuple(h.view(batch_size, 2, -1) for h in hidden)\n\n # Apply the bridge\n output = tuple(layer(h) for layer, h in zip(self.layers, hidden))\n\n # Reshape the tensors if the parameters are shared\n if self.share_bidirectional_parameters:\n # shape: (batch_size, decoder_hidden_size)\n output = tuple(h.view(batch_size, -1) for h in output)\n\n # Undo the tuple if there's only 1 element\n if len(output) == 1:\n output = output[0]\n return output","def hidden():\n return False","def forward(self, hidden_states):\n # Common transformations (dense layer, layer norm + activation function) performed on text, KG and protein data\n # transform is initialized in the parent BigBirdLMPredictionHead class\n hidden_states = self.transform(hidden_states)\n\n # The first part is processed with the text decoder, the second with the entity decoder, and the third with the\n # protein decoder to map to the text, kg, and protein vocab size, respectively\n text_hidden_states_to_vocab = self.text_decoder(hidden_states[:, : self.kg_start_idx])\n ent_hidden_states_to_kg_vocab = self.entity_decoder(\n hidden_states[:, self.kg_start_idx : self.prot_start_idx]\n )\n prot_hidden_states_to_prot_vocab = self.prot_decoder(\n hidden_states[:, self.prot_start_idx :]\n )\n\n return (\n text_hidden_states_to_vocab,\n ent_hidden_states_to_kg_vocab,\n prot_hidden_states_to_prot_vocab,\n )","def detach_hidden(self, zero=False):\n if zero:\n self.hidden = self._make_hidden(self.batch_size)\n else:\n self.hidden = self.hidden.detach()","def init_hidden_state(self, encoder_out: torch.Tensor):\n pass","def forward(self, x, hidden):\n emb_x = self.emb_layer(x)\n lstm_out, hidden = self.lstm(emb_x, hidden)\n if self.bidirectional:\n # separate to forward and backward\n # following code reshapes LSTM output to:\n # (batch size, seq length, num directions, hidden dimensions)\n # where direction '0' is forward and direction '1' is backward\n lstm_out = lstm_out.contiguous().view(-1, self.seq_len, 2, self.hidden_dim)\n # get backward output in first node\n lstm_out_bw = lstm_out[:, 0, 1, :]\n # get forward output in last node\n lstm_out_fw = lstm_out[:, -1, 0, :]\n # we may simple concatenate forward & backward outputs,\n # or add them, multiply or average; in this case i used average\n lstm_out = torch.add(input=lstm_out_bw, alpha=1, other=lstm_out_fw)\n lstm_out = torch.div(lstm_out, 2)\n else:\n lstm_out = lstm_out[:, -1]\n \n assert lstm_out.shape[-1] == self.hidden_dim, (lstm_out.shape, self.hidden_dim)\n lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)\n \n d_out = self.dropout(lstm_out)\n fc_out = self.output_layer(d_out)\n sig_out = torch.sigmoid(fc_out)\n \n # return last sigmoid output and hidden state\n return sig_out, hidden","def test_switch_hidden1(self):\n self.test_object.switch_hidden()\n self.assertFalse(self.test_object.get_hidden())","def forward(self, input, hidden, key=None):\n for cell_id, cell in enumerate(self.cells):\n hidden[cell_id] = cell(input, hidden[cell_id])\n if not isinstance(hidden[cell_id], (list, tuple)):\n hidden[cell_id] = [hidden[cell_id]]\n input = hidden[cell_id][0]\n\n if key is not None:\n logits = self.policies[key](hidden[-1][0])\n values = self.values[key](hidden[-1][0])\n return logits, values, hidden\n\n return hidden","def hidden(self) -> Generator[None, None, None]:\n if self._hidden_level == 0:\n self.hide()\n self._hidden_level += 1\n try:\n yield\n finally:\n self._hidden_level -= 1\n if self._hidden_level == 0:\n self.show()","def toggle_hidden(self):\n if self.hidden:\n self.show()\n else:\n self.hide()","def extract_hidden_states(self, output):\n # Intermediate hidden states\n output_fw_intermediate = output[:,:-1,0:self._hidden_size]\n output_bw_intermediate = output[:,1:,self._hidden_size:] \n \n # Last hidden states\n output_fw = output[:,-1,0:self._hidden_size]\n output_bw = output[:,0,self._hidden_size:]\n last_ht = torch.cat((output_fw, output_bw), -1)\n \n return last_ht, output_fw_intermediate, output_bw_intermediate","def detach_hidden(self, zero=False):\n if zero:\n self.hidden = self._make_hidden(self.batch_size)\n else:\n self.hidden[0].detach()","def test_switch_hidden2(self):\n self.test_object.switch_hidden()\n self.test_object.switch_hidden()\n self.assertTrue(self.test_object.get_hidden())","def forward(self, x):\n x, self.hidden = self.gru(x, self.hidden)\n self.detach_hidden()\n x = self.dropout(x)\n x = self.out(x)\n return x","def backward(self, dout):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n for l in range(len(self.layers)-1,-1,-1):\n act_dout = self.activations[l].backward(dout)\n dout = self.layers[l].backward(act_dout)\n ########################\n # END OF YOUR CODE #\n #######################\n\n return","def _set_state_after_forward(self):\n for chunk_id, chunk in self.client.chunk_list.generate_chunk():\n if (\n chunk.get_state() == ChunkState.HOLD\n or chunk.get_state() == ChunkState.HOLD_AFTER_FWD\n ):\n chunk.set_unused()\n self.client.set_all_tensors_state_in_chunk(chunk_id, TensorState.HOLD)","def stabilize(self, hidden, num_iters=1):\n for i in range(num_iters):\n g_off, hidden = self.add_transit(old_hidden=hidden)\n return g_off, hidden","def propdown(self, hid):\n pre_sigmoid_activation = \\\n T.dot(hid, self.hidden_layer.W.T) + self.vbias\n return [pre_sigmoid_activation, T.nnet.sigmoid(pre_sigmoid_activation)]","def add_state_desires(self):\n raise NotImplementedError()","def init_hidden(self):\n # TODO ========================\n # initialize the hidden states to zero\n\n initial_hidden = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)\n return initial_hidden # a parameter tensor of shape (self.num_layers, self.batch_size, self.hidden_size)","def initialize_state(self):\n super(InverseChain, self).initialize_state()","def _init_state(self, encoder_hidden):\n if encoder_hidden is None:\n return None\n if isinstance(encoder_hidden, tuple):\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\n else:\n encoder_hidden = self._cat_directions(encoder_hidden)\n return encoder_hidden","def _init_state(self, encoder_hidden):\n if encoder_hidden is None:\n return None\n if isinstance(encoder_hidden, tuple):\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\n else:\n encoder_hidden = self._cat_directions(encoder_hidden)\n return encoder_hidden","def setIsolateHidden( self, state ):\n self._isolatedHidden = state\n \n super(XNode, self).setVisible(self.isVisible())","def gibbs_step(self, visible):\n hidden_prob = self.probabilities_hidden(visible)\n hidden_state = self.sample(hidden_prob)\n visible_prob = self.probabilities_visible(hidden_state)\n visible_state = visible_prob\n return hidden_prob, hidden_state, visible_prob, visible_state","def post_backward_generator(self):\n pass","def reset_hidden(self, hidden, reset_flags):\n # detach it from history (pytorch mechanics)\n if self.rnn_type in ['lstm', 'mylstm']:\n h = Variable(hidden[0].data)\n c = Variable(hidden[1].data)\n hidden = (h, c)\n for b, flag in enumerate(reset_flags):\n if flag.data[0] == 1: # data[0] access the data in Variable\n hidden[0][:, b, :].data.fill_(0)\n hidden[1][:, b, :].data.fill_(0)\n elif self.rnn_type == 'gru':\n hidden = Variable(hidden.data)\n for b, flag in enumerate(reset_flags):\n if flag.data[0] == 1: # data[0] access the data in Variable\n hidden[:, b, :].data.fill_(0)\n else:\n print(\"Not support this type yet.\")\n exit(0)\n return hidden","def forward(self):\n raise NotImplemented","def forward(self):\n raise NotImplemented","def forward(self):\n raise NotImplemented","def forward(self, input, hidden):\n combined = torch.cat((input, hidden), 1)\n hidden = self.i2h(combined)\n output = self.i2o(combined)\n output = self.softmax(output)\n return output, hidden","def backward(self):\n raise NotImplemented","def backward(self):\n raise NotImplemented","def backward(self):\n raise NotImplemented","def hidden(self):\n return self._hidden","def forward(self, state):\n x = self.nonlin(self.fc1(self.in_fn(state)))\n x = self.drop_layer(x)\n x = self.nonlin(self.fc2(x))\n x = self.drop_layer(x)\n return self.fc3(x)","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def backward(self):\n raise NotImplementedError","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def init_hidden(self):\n if isinstance(self.rnn, nn.GRU):\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\n elif isinstance(self.rnn, nn.LSTM):\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))","def forward(self, inp, state):\n emb = self.drop(self.encoder(inp))\n y, state_next = self.rnn(emb, state)\n y = self.drop(y)\n y = self.decoder(y)\n return y, state_next","def flip(self):","def forward(self, state):\n x = self.conv(state).view(-1, self.hid_size)\n x = self.fc1(x)\n x = F.relu(x)\n return self.fc2(x)","def is_hidden(self):\n return self.has_label(HIDDEN_LABEL)","def forward_pass(self):","def toggle(self) -> None:","def toggle(self) -> None:","def hidden(self) -> bool:\n return False","def hidden(self) -> bool:\n return False","def init_hidden(self, batch_size, device):\n if self.mode == 'LSTM':\n return (torch.ones((1+self.bidirectional , batch_size, self.hidden_dim), device=device),\n torch.ones((1+self.bidirectional, batch_size, self.hidden_dim), device=device))\n else:\n return torch.ones((1+self.bidirectional, batch_size, self.hidden_dim), device=device)","def post_backward_discriminator(self):\n pass","def forward_step(self, layer: int, hidden: AmbiguousHidden, input_: Tensor) -> AmbiguousHidden:\n hx, cx = hidden\n\n # Forget gate\n f_g = torch.sigmoid(self.gates[layer]['if'](input_) + self.gates[layer]['hf'](hx))\n\n # Input gate\n i_g = torch.sigmoid(self.gates[layer]['ii'](input_) + self.gates[layer]['hi'](hx))\n\n # Output gate\n o_g = torch.sigmoid(self.gates[layer]['io'](input_) + self.gates[layer]['ho'](hx))\n\n # Intermediate cell state\n c_tilde_g = torch.tanh(self.gates[layer]['ig'](input_) + self.gates[layer]['hg'](hx))\n\n # New cell state\n cx = f_g * cx + i_g * c_tilde_g\n\n # New hidden state\n hx = o_g * torch.tanh(cx)\n\n return hx, cx","def toggle(self):","def init_hidden_state(self,batch_size):\n h = torch.zeros(batch_size,self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size,self.decoder_dim).to(device)\n return h, c","def backward(self, top, propagate_down, bottom):\n\t\tpass","def flip_state(self):\n logging.debug(\"element selected\")\n if len(self._contents) == 0:\n self.deactivate()\n else:\n if self._contents[self.pointer][2] == 'exit':\n self.deactivate()\n return\n self.states[self.pointer] = not self.states[self.pointer] #Just inverting.\n self.refresh()","def toggle_hidden(self):\n self.show_hidden = not self.show_hidden\n self.reload('.')","def _repackage(self):\n self.hidden = _var(self.hidden.data)\n if self.G.ntype == \"lstm\":\n self.state = _var(self.state.data)","def forward(self, input, hidden):\r\n output, hidden = self.rnn(input, hidden)\r\n output = f.log_softmax(self.out(output.squeeze(1)), 1)\r\n return output, hidden","def hidden(self, value):\n if value is not None:\n value.get_shape().assert_is_compatible_with(self._output_shape)\n self._hidden = value","def forward(self, x, hidden):\n batch_size=x.shape[0]\n\n x = self.embed(x)\n\n x,hidden = self.lstm(x,hidden)\n\n x = x.reshape(-1,self.hidden_dim)\n\n x = self.drp(x)\n\n x = self.fc(x)\n\n sig_out = self.sigmoid(x)\n\n # return last sigmoid output and hidden state\n sig_out = sig_out.reshape(batch_size,-1)\n sig_out = sig_out[:,-1]\n\n return sig_out, hidden","def forward_backward(observations):\n\n # -------------------------------------------------------------------------\n # YOUR CODE GOES HERE\n #\n # observations = [(4, 3), (4, 2), (3, 2), (4, 0), (2, 0), (2, 0), (3, 2), \n # (4, 2), (2, 3), (3, 5)]\n num_time_steps = len(observations)\n forward_messages = [None] * num_time_steps\n forward_messages[0] = prior_matrix\n # # # TODO: Compute the forward messages\n for i,x_i in enumerate(observations):\n if x_i:\n obs_index = obs_state_index_map[x_i]\n pi_0 = forward_messages[i]\n # print(len(B[:obs_index]))\n weights = np.multiply(pi_0, B[:,obs_index])\n # x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\n else:\n weights = forward_messages[i]\n # print(weights)\n x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\n if i+1 < len(forward_messages):\n forward_messages[i+1] = x#normalize(x)\n # break\n\n ## forward messages as dictionary\n # for_dict = [None]*num_time_steps\n # for j,f in enumerate(forward_messages):\n # x = Distribution()\n # for i,x_i in enumerate(f):\n # if x_i == 0:\n # continue\n # # print(i,x_i)\n # x[all_possible_hidden_states[i]] = x_i\n # for_dict[j] = x.renormalize()\n # print(for_dict[3])\n\n # print('--------------\\n-----------------\\n')\n\n\n backward_messages = [None] * num_time_steps\n # backward_messages[-1] = [1]*len(prior_matrix)\n message = np.ones(len(all_possible_hidden_states), dtype=np.float64)\n backward_messages[-1] = message/len(all_possible_hidden_states)\n \n# ****\n ## Backwards messages\n for i,x_i in enumerate(reversed(observations)):\n # print(x_i)\n if x_i:\n obs_index = obs_state_index_map[x_i]\n pi = backward_messages[-1-i]\n weights = np.multiply(pi, B[:,obs_index])\n else:\n weights = backward_messages[-1-i]\n # print(i)\n x = sum([A[:,j]*w_i for j,w_i in enumerate(weights)])\n\n if i+1 < len(backward_messages):\n backward_messages[-2-i] = x#normalize(x)\n\n ## backward messages as dictionary\n # back_dict = [None]*num_time_steps\n # for j,b in enumerate(backward_messages):\n # x = Distribution()\n # if b == None:\n # continue\n # for i,x_i in enumerate(b):\n # if x_i == 0 or x_i==None:\n # continue\n # # print(i,x_i)\n # x[all_possible_hidden_states[i]] = x_i\n # back_dict[j] = x.renormalize()\n \n # print(back_dict[0])\n # print(A[:10,:10])\n # print('\\n-----------------\\n', B[:10,:10])\n\n # print(backward_messages[2])\n # backward_messages[0] = forward_messages[0]\n # # ## marginals as matrix\n marginals = [None] * num_time_steps \n for i,x_i in enumerate(observations):\n if x_i:\n obs_index = obs_state_index_map[x_i]\n marginals[i] = np.multiply(np.multiply(backward_messages[i],\n forward_messages[i]),\n B[:,obs_index])\n else:\n marginals[i] = np.multiply(backward_messages[i],forward_messages[i])\n # if i == 0:\n # marginals[i] = np.multiply(backward_messages[i], B[:,obs_index])\n # elif i == len(observations)-1:\n # marginals[i] = np.multiply(forward_messages[i], B[:,obs_index])\n # else:\n\n ## marginals as dictionary\n marg_dict = [None]*num_time_steps\n for j,m in enumerate(marginals):\n x = Distribution()\n for i,x_i in enumerate(m):\n if x_i == 0 or x_i==None:\n continue\n x[all_possible_hidden_states[i]] = x_i\n marg_dict[j] = x.renormalize()\n # print(marginals[i])\n # print(A[:10, :10], '\\n')\n # print(B[:10, :10], '\\n')\n # print(marg_dict)\n return marg_dict","def detach_hidden(hidden: Any) -> Any:\n return apply_to_tensor(hidden, Tensor.detach)","def hidden_layers(self):\n\t\tif self.hidden is None:\n\t\t\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\n\t\t\tlast_hidden = self.x\n\t\t\tif self.covnet == 1:\n\t\t\t\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\n\t\t\telif self.covnet == 2:\n\t\t\t\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\n\t\t\t\t self.layerSize[0], self.layerSize[1])\n\t\t\telse:\n\n\t\t\t\tself._drouput = 'dr'\n\t\t\t\t# self.hidden.append(self.x)\n\t\t\t\tfor i in range(1, len(self.all_layer_sizes)):\n\t\t\t\t\tname_scope = 'hidden' + str(i - 1)\n\t\t\t\t\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\n\t\t\t\t\tactivation_function = self.activation_function\n\t\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\n\t\t\t\t\t last_hidden)\n\t\t\t\tname_scope = 'final_layer'\n\t\t\t\trow_size, col_size = self.layerSize[-1], self.num_of_classes\n\t\t\t\tactivation_function = None\n\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\n\t\treturn self.hidden","def backward(self, top, propagate_down, bottom):\r\n pass","def init_hidden(self):\n pass","def init_hidden(self):\n pass","def _hidden_activation(self, inputs):\n if self.act_enc is None:\n act_enc = lambda x: x\n else:\n act_enc = self.act_enc\n return act_enc(self._mappings(inputs))","def forward(self)->None:","def transparent_forward(self, inp, hidden=None, give_gates=False, debug=False):\n\n lseq = inp.shape[0]\n nseq = inp.shape[1]\n # ispad = (input == self.padding)\n\n if hidden is None:\n hidden = self.init_hidden(nseq)\n\n H = torch.zeros(lseq, self.nhid, nseq)\n if give_gates:\n Z = torch.zeros(lseq, self.nhid, nseq)\n R = torch.zeros(lseq, self.nhid, nseq)\n \n # because pytorch only returns hidden activity in the last time step,\n # we need to unroll it manually. \n O = torch.zeros(lseq, nseq, self.decoder.out_features)\n if self.recoder is None:\n emb = inp\n else:\n emb = self.recoder(inp)\n for t in range(lseq):\n if give_gates:\n out, hidden, ZR = self.rnn(emb[t:t+1,...], hidden, give_gates=True)\n Z[t,:,:] = ZR[0].squeeze(0).T\n R[t,:,:] = ZR[1].squeeze(0).T\n else:\n out, hidden = self.rnn(emb[t:t+1,...], hidden)\n dec = self.decoder(out)\n # naan = torch.ones(hidden.squeeze(0).shape)*np.nan\n # H[t,:,:] = torch.where(~ispad[t:t+1,:].T, hidden.squeeze(0), naan).T\n H[t,:,:] = hidden.squeeze(0).T\n O[t,:,:] = dec.squeeze(0)\n\n if give_gates:\n if debug:\n return O, H, Z, R, emb\n else:\n return O, H, Z, R\n else:\n if debug:\n return O, H, emb\n else:\n return O, H","def act(self, state):\n return","def forward_backward(self, x):\n observation_log_probs = self._observation_log_probs(x, mask=None)\n with tf.name_scope('forward_belief_propagation'):\n self.forward_log_probs = self._forward(observation_log_probs)\n\n with tf.name_scope('backward_belief_propagation'):\n self.backward_log_probs = self._backward(observation_log_probs)","def init_hidden_state(self, batch_size):\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\n return h, c","def init_hidden_state(self, batch_size):\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\n return h, c","def init_hidden_state(self, batch_size):\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\n return h, c","def _localSetState(self,pdict):\n super()._localSetState(pdict)\n self.transition = pdict.pop('transition')\n self.steadyStatePb = pdict.pop('steadyStatePb')","def is_hidden():\n return False","def is_hidden():\n return False","def forward(self):\n pass","def forward(self):\n pass","def transparent_forward(self, input, hidden, give_gates=False, debug=False):\n\n lseq, nseq = input.shape\n ispad = (input == self.padding)\n\n H = torch.zeros(lseq, self.nhid, nseq)\n if give_gates:\n Z = torch.zeros(lseq, self.nhid, nseq)\n R = torch.zeros(lseq, self.nhid, nseq)\n \n # because pytorch only returns hidden activity in the last time step,\n # we need to unroll it manually. \n O = torch.zeros(lseq, nseq, self.decoder.out_features)\n emb = self.encoder(input)\n for t in range(lseq):\n if give_gates:\n out, hidden, ZR = self.rnn(emb[t:t+1,...], hidden, give_gates=True)\n Z[t,:,:] = ZR[0].squeeze(0).T\n R[t,:,:] = ZR[1].squeeze(0).T\n else:\n out, hidden = self.rnn(emb[t:t+1,...], hidden)\n dec = self.decoder(out)\n # naan = torch.ones(hidden.squeeze(0).shape)*np.nan\n # H[t,:,:] = torch.where(~ispad[t:t+1,:].T, hidden.squeeze(0), naan).T\n H[t,:,:] = hidden.squeeze(0).T\n O[t,:,:] = dec.squeeze(0)\n\n if give_gates:\n if debug:\n return O, H, Z, R, emb\n else:\n return O, H, Z, R\n else:\n if debug:\n return O, H, emb\n else:\n return O, H","def hidden_singles(self):\n self.change = True\n while self.change:\n self.hidden_round()","def forward(self, input, hidden, give_gates=False, debug=False):\n\n emb = self.encoder(input)\n if emb.dim()<3:\n emb = emb.unsqueeze(0)\n\n if give_gates:\n output, hidden, extras = self.rnn(emb, hidden, give_gates)\n else:\n output, hidden = self.rnn(emb, hidden)\n\n # decoded = self.softmax(self.decoder(output))\n decoded = self.decoder(output)\n\n if give_gates:\n if debug:\n return decoded, hidden, extras, emb\n else:\n return decoded, hidden, extras\n else:\n if debug:\n return decoded, hidden, emb\n else:\n return decoded, hidden","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass"],"string":"[\n \"def _bridge_bidirectional_hidden(self, hidden):\\n num_layers = hidden.size(0) // 2\\n _, batch_size, hidden_size = hidden.size()\\n return hidden.view(num_layers, 2, batch_size, hidden_size)\\\\\\n .transpose(1, 2).contiguous().view(num_layers, batch_size, hidden_size * 2)\",\n \"def forward(self, states):\\n raise NotImplementedError()\",\n \"def init_hidden(self, batch_size):\\r\\n \\r\\n self.hidden_state = (\\r\\n torch.zeros(((1+self.bidirectional)*self.num_layers,\\r\\n batch_size,\\r\\n self.hidden_size)).to(self.device),\\r\\n torch.zeros(((1+self.bidirectional)*self.num_layers, \\r\\n batch_size, \\r\\n self.hidden_size)).to(self.device))\",\n \"def toggle_hidden(self):\\n AbstractChild.toggle_hidden(self)\\n self.accFrame.update_values()\\n self.botFrame.update_values()\\n # On toggle hidden\\n self.on_toggle_hidden()\",\n \"def hidden(self):\\n return self._hidden\",\n \"def forward(self, node_hidden, edge_hidden, adj_matrix, mask):\\n # x.shape = (batch, max_length, d_atom)\\n node_hidden = self.dropout(self.norm(node_hidden))\\n node_hidden_first, edge_hidden_temp = self.self_attn(node_hidden, node_hidden, edge_hidden, adj_matrix, mask)\\n # the first residue block\\n node_hidden_first = node_hidden + self.dropout(self.norm(node_hidden_first))\\n node_hidden_second = self.feed_forward(node_hidden_first)\\n # the second residue block\\n return node_hidden + node_hidden_first + self.dropout(self.norm(node_hidden_second)), edge_hidden\",\n \"def hidden(self, hidden):\\n\\n self._hidden = hidden\",\n \"def forward(self, input, states):\\n (hidden, cell) = states\\n\\n input = input + self.transform(hidden)\\n\\n forget_gate = torch.sigmoid(self.forget(input))\\n input_gate = torch.sigmoid(self.input(input))\\n output_gate = torch.sigmoid(self.output(input))\\n state_gate = torch.tanh(self.state(input))\\n\\n # Update internal cell state\\n cell = forget_gate * cell + input_gate * state_gate\\n hidden = output_gate * torch.tanh(cell)\\n\\n return hidden, cell\",\n \"def _transit_state(self) -> None:\\n pass\",\n \"def _TransformHidden(self, _):\\n raise NotImplementedError()\",\n \"def extract_hidden_states(self, output):\\n \\n # Extracting the forward and backward hidden states from the last BiLSTM layer\\n # output (batch_size, sequence length, 2 * hidden dim)\\n output_fw = output[:,:,0:self._hidden_size]\\n output_bw = output[:,:,self._hidden_size:]\\n \\n hidden_states = torch.cat((output_fw, output_bw),-1)\\n \\n return hidden_states\",\n \"def forward(self, input, hidden_states):\\n h, c = self.ih2h(input, hidden_states[0])\\n next_hiddens = [(h, c)]\\n h, c = self.h2h(h, hidden_states[1])\\n next_hiddens.append((h, c))\\n output = self.log_softmax(self.h2o(h))\\n return output, next_hiddens\",\n \"def forward(self, hidden: Union[torch.Tensor, Tuple[torch.Tensor, ...]]) -> Union[torch.Tensor, Tuple[torch.Tensor, ...]]:\\n # First, map the non-tuple version to a 1-tuple for easier processing.\\n # We will undo this at the end\\n if not isinstance(hidden, tuple):\\n hidden = (hidden,)\\n\\n batch_size, hidden_size = hidden[0].size()\\n\\n # If we are going to share parameters across the forward and backward\\n # directions, then we need to separate them in the tensors\\n if self.share_bidirectional_parameters:\\n # shape: (batch_size, 2, encoder_hidden_size // 2)\\n hidden = tuple(h.view(batch_size, 2, -1) for h in hidden)\\n\\n # Apply the bridge\\n output = tuple(layer(h) for layer, h in zip(self.layers, hidden))\\n\\n # Reshape the tensors if the parameters are shared\\n if self.share_bidirectional_parameters:\\n # shape: (batch_size, decoder_hidden_size)\\n output = tuple(h.view(batch_size, -1) for h in output)\\n\\n # Undo the tuple if there's only 1 element\\n if len(output) == 1:\\n output = output[0]\\n return output\",\n \"def hidden():\\n return False\",\n \"def forward(self, hidden_states):\\n # Common transformations (dense layer, layer norm + activation function) performed on text, KG and protein data\\n # transform is initialized in the parent BigBirdLMPredictionHead class\\n hidden_states = self.transform(hidden_states)\\n\\n # The first part is processed with the text decoder, the second with the entity decoder, and the third with the\\n # protein decoder to map to the text, kg, and protein vocab size, respectively\\n text_hidden_states_to_vocab = self.text_decoder(hidden_states[:, : self.kg_start_idx])\\n ent_hidden_states_to_kg_vocab = self.entity_decoder(\\n hidden_states[:, self.kg_start_idx : self.prot_start_idx]\\n )\\n prot_hidden_states_to_prot_vocab = self.prot_decoder(\\n hidden_states[:, self.prot_start_idx :]\\n )\\n\\n return (\\n text_hidden_states_to_vocab,\\n ent_hidden_states_to_kg_vocab,\\n prot_hidden_states_to_prot_vocab,\\n )\",\n \"def detach_hidden(self, zero=False):\\n if zero:\\n self.hidden = self._make_hidden(self.batch_size)\\n else:\\n self.hidden = self.hidden.detach()\",\n \"def init_hidden_state(self, encoder_out: torch.Tensor):\\n pass\",\n \"def forward(self, x, hidden):\\n emb_x = self.emb_layer(x)\\n lstm_out, hidden = self.lstm(emb_x, hidden)\\n if self.bidirectional:\\n # separate to forward and backward\\n # following code reshapes LSTM output to:\\n # (batch size, seq length, num directions, hidden dimensions)\\n # where direction '0' is forward and direction '1' is backward\\n lstm_out = lstm_out.contiguous().view(-1, self.seq_len, 2, self.hidden_dim)\\n # get backward output in first node\\n lstm_out_bw = lstm_out[:, 0, 1, :]\\n # get forward output in last node\\n lstm_out_fw = lstm_out[:, -1, 0, :]\\n # we may simple concatenate forward & backward outputs,\\n # or add them, multiply or average; in this case i used average\\n lstm_out = torch.add(input=lstm_out_bw, alpha=1, other=lstm_out_fw)\\n lstm_out = torch.div(lstm_out, 2)\\n else:\\n lstm_out = lstm_out[:, -1]\\n \\n assert lstm_out.shape[-1] == self.hidden_dim, (lstm_out.shape, self.hidden_dim)\\n lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)\\n \\n d_out = self.dropout(lstm_out)\\n fc_out = self.output_layer(d_out)\\n sig_out = torch.sigmoid(fc_out)\\n \\n # return last sigmoid output and hidden state\\n return sig_out, hidden\",\n \"def test_switch_hidden1(self):\\n self.test_object.switch_hidden()\\n self.assertFalse(self.test_object.get_hidden())\",\n \"def forward(self, input, hidden, key=None):\\n for cell_id, cell in enumerate(self.cells):\\n hidden[cell_id] = cell(input, hidden[cell_id])\\n if not isinstance(hidden[cell_id], (list, tuple)):\\n hidden[cell_id] = [hidden[cell_id]]\\n input = hidden[cell_id][0]\\n\\n if key is not None:\\n logits = self.policies[key](hidden[-1][0])\\n values = self.values[key](hidden[-1][0])\\n return logits, values, hidden\\n\\n return hidden\",\n \"def hidden(self) -> Generator[None, None, None]:\\n if self._hidden_level == 0:\\n self.hide()\\n self._hidden_level += 1\\n try:\\n yield\\n finally:\\n self._hidden_level -= 1\\n if self._hidden_level == 0:\\n self.show()\",\n \"def toggle_hidden(self):\\n if self.hidden:\\n self.show()\\n else:\\n self.hide()\",\n \"def extract_hidden_states(self, output):\\n # Intermediate hidden states\\n output_fw_intermediate = output[:,:-1,0:self._hidden_size]\\n output_bw_intermediate = output[:,1:,self._hidden_size:] \\n \\n # Last hidden states\\n output_fw = output[:,-1,0:self._hidden_size]\\n output_bw = output[:,0,self._hidden_size:]\\n last_ht = torch.cat((output_fw, output_bw), -1)\\n \\n return last_ht, output_fw_intermediate, output_bw_intermediate\",\n \"def detach_hidden(self, zero=False):\\n if zero:\\n self.hidden = self._make_hidden(self.batch_size)\\n else:\\n self.hidden[0].detach()\",\n \"def test_switch_hidden2(self):\\n self.test_object.switch_hidden()\\n self.test_object.switch_hidden()\\n self.assertTrue(self.test_object.get_hidden())\",\n \"def forward(self, x):\\n x, self.hidden = self.gru(x, self.hidden)\\n self.detach_hidden()\\n x = self.dropout(x)\\n x = self.out(x)\\n return x\",\n \"def backward(self, dout):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n for l in range(len(self.layers)-1,-1,-1):\\n act_dout = self.activations[l].backward(dout)\\n dout = self.layers[l].backward(act_dout)\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return\",\n \"def _set_state_after_forward(self):\\n for chunk_id, chunk in self.client.chunk_list.generate_chunk():\\n if (\\n chunk.get_state() == ChunkState.HOLD\\n or chunk.get_state() == ChunkState.HOLD_AFTER_FWD\\n ):\\n chunk.set_unused()\\n self.client.set_all_tensors_state_in_chunk(chunk_id, TensorState.HOLD)\",\n \"def stabilize(self, hidden, num_iters=1):\\n for i in range(num_iters):\\n g_off, hidden = self.add_transit(old_hidden=hidden)\\n return g_off, hidden\",\n \"def propdown(self, hid):\\n pre_sigmoid_activation = \\\\\\n T.dot(hid, self.hidden_layer.W.T) + self.vbias\\n return [pre_sigmoid_activation, T.nnet.sigmoid(pre_sigmoid_activation)]\",\n \"def add_state_desires(self):\\n raise NotImplementedError()\",\n \"def init_hidden(self):\\n # TODO ========================\\n # initialize the hidden states to zero\\n\\n initial_hidden = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)\\n return initial_hidden # a parameter tensor of shape (self.num_layers, self.batch_size, self.hidden_size)\",\n \"def initialize_state(self):\\n super(InverseChain, self).initialize_state()\",\n \"def _init_state(self, encoder_hidden):\\n if encoder_hidden is None:\\n return None\\n if isinstance(encoder_hidden, tuple):\\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\\n else:\\n encoder_hidden = self._cat_directions(encoder_hidden)\\n return encoder_hidden\",\n \"def _init_state(self, encoder_hidden):\\n if encoder_hidden is None:\\n return None\\n if isinstance(encoder_hidden, tuple):\\n encoder_hidden = tuple([self._cat_directions(h) for h in encoder_hidden])\\n else:\\n encoder_hidden = self._cat_directions(encoder_hidden)\\n return encoder_hidden\",\n \"def setIsolateHidden( self, state ):\\n self._isolatedHidden = state\\n \\n super(XNode, self).setVisible(self.isVisible())\",\n \"def gibbs_step(self, visible):\\n hidden_prob = self.probabilities_hidden(visible)\\n hidden_state = self.sample(hidden_prob)\\n visible_prob = self.probabilities_visible(hidden_state)\\n visible_state = visible_prob\\n return hidden_prob, hidden_state, visible_prob, visible_state\",\n \"def post_backward_generator(self):\\n pass\",\n \"def reset_hidden(self, hidden, reset_flags):\\n # detach it from history (pytorch mechanics)\\n if self.rnn_type in ['lstm', 'mylstm']:\\n h = Variable(hidden[0].data)\\n c = Variable(hidden[1].data)\\n hidden = (h, c)\\n for b, flag in enumerate(reset_flags):\\n if flag.data[0] == 1: # data[0] access the data in Variable\\n hidden[0][:, b, :].data.fill_(0)\\n hidden[1][:, b, :].data.fill_(0)\\n elif self.rnn_type == 'gru':\\n hidden = Variable(hidden.data)\\n for b, flag in enumerate(reset_flags):\\n if flag.data[0] == 1: # data[0] access the data in Variable\\n hidden[:, b, :].data.fill_(0)\\n else:\\n print(\\\"Not support this type yet.\\\")\\n exit(0)\\n return hidden\",\n \"def forward(self):\\n raise NotImplemented\",\n \"def forward(self):\\n raise NotImplemented\",\n \"def forward(self):\\n raise NotImplemented\",\n \"def forward(self, input, hidden):\\n combined = torch.cat((input, hidden), 1)\\n hidden = self.i2h(combined)\\n output = self.i2o(combined)\\n output = self.softmax(output)\\n return output, hidden\",\n \"def backward(self):\\n raise NotImplemented\",\n \"def backward(self):\\n raise NotImplemented\",\n \"def backward(self):\\n raise NotImplemented\",\n \"def hidden(self):\\n return self._hidden\",\n \"def forward(self, state):\\n x = self.nonlin(self.fc1(self.in_fn(state)))\\n x = self.drop_layer(x)\\n x = self.nonlin(self.fc2(x))\\n x = self.drop_layer(x)\\n return self.fc3(x)\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU) or isinstance(self.rnn, nn.RNN):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def backward(self):\\n raise NotImplementedError\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def init_hidden(self):\\n if isinstance(self.rnn, nn.GRU):\\n return torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device)\\n elif isinstance(self.rnn, nn.LSTM):\\n return (torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device),\\n torch.zeros(self.num_directions * self.num_layers, 1, self.hidden_size, device=device))\",\n \"def forward(self, inp, state):\\n emb = self.drop(self.encoder(inp))\\n y, state_next = self.rnn(emb, state)\\n y = self.drop(y)\\n y = self.decoder(y)\\n return y, state_next\",\n \"def flip(self):\",\n \"def forward(self, state):\\n x = self.conv(state).view(-1, self.hid_size)\\n x = self.fc1(x)\\n x = F.relu(x)\\n return self.fc2(x)\",\n \"def is_hidden(self):\\n return self.has_label(HIDDEN_LABEL)\",\n \"def forward_pass(self):\",\n \"def toggle(self) -> None:\",\n \"def toggle(self) -> None:\",\n \"def hidden(self) -> bool:\\n return False\",\n \"def hidden(self) -> bool:\\n return False\",\n \"def init_hidden(self, batch_size, device):\\n if self.mode == 'LSTM':\\n return (torch.ones((1+self.bidirectional , batch_size, self.hidden_dim), device=device),\\n torch.ones((1+self.bidirectional, batch_size, self.hidden_dim), device=device))\\n else:\\n return torch.ones((1+self.bidirectional, batch_size, self.hidden_dim), device=device)\",\n \"def post_backward_discriminator(self):\\n pass\",\n \"def forward_step(self, layer: int, hidden: AmbiguousHidden, input_: Tensor) -> AmbiguousHidden:\\n hx, cx = hidden\\n\\n # Forget gate\\n f_g = torch.sigmoid(self.gates[layer]['if'](input_) + self.gates[layer]['hf'](hx))\\n\\n # Input gate\\n i_g = torch.sigmoid(self.gates[layer]['ii'](input_) + self.gates[layer]['hi'](hx))\\n\\n # Output gate\\n o_g = torch.sigmoid(self.gates[layer]['io'](input_) + self.gates[layer]['ho'](hx))\\n\\n # Intermediate cell state\\n c_tilde_g = torch.tanh(self.gates[layer]['ig'](input_) + self.gates[layer]['hg'](hx))\\n\\n # New cell state\\n cx = f_g * cx + i_g * c_tilde_g\\n\\n # New hidden state\\n hx = o_g * torch.tanh(cx)\\n\\n return hx, cx\",\n \"def toggle(self):\",\n \"def init_hidden_state(self,batch_size):\\n h = torch.zeros(batch_size,self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size,self.decoder_dim).to(device)\\n return h, c\",\n \"def backward(self, top, propagate_down, bottom):\\n\\t\\tpass\",\n \"def flip_state(self):\\n logging.debug(\\\"element selected\\\")\\n if len(self._contents) == 0:\\n self.deactivate()\\n else:\\n if self._contents[self.pointer][2] == 'exit':\\n self.deactivate()\\n return\\n self.states[self.pointer] = not self.states[self.pointer] #Just inverting.\\n self.refresh()\",\n \"def toggle_hidden(self):\\n self.show_hidden = not self.show_hidden\\n self.reload('.')\",\n \"def _repackage(self):\\n self.hidden = _var(self.hidden.data)\\n if self.G.ntype == \\\"lstm\\\":\\n self.state = _var(self.state.data)\",\n \"def forward(self, input, hidden):\\r\\n output, hidden = self.rnn(input, hidden)\\r\\n output = f.log_softmax(self.out(output.squeeze(1)), 1)\\r\\n return output, hidden\",\n \"def hidden(self, value):\\n if value is not None:\\n value.get_shape().assert_is_compatible_with(self._output_shape)\\n self._hidden = value\",\n \"def forward(self, x, hidden):\\n batch_size=x.shape[0]\\n\\n x = self.embed(x)\\n\\n x,hidden = self.lstm(x,hidden)\\n\\n x = x.reshape(-1,self.hidden_dim)\\n\\n x = self.drp(x)\\n\\n x = self.fc(x)\\n\\n sig_out = self.sigmoid(x)\\n\\n # return last sigmoid output and hidden state\\n sig_out = sig_out.reshape(batch_size,-1)\\n sig_out = sig_out[:,-1]\\n\\n return sig_out, hidden\",\n \"def forward_backward(observations):\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE GOES HERE\\n #\\n # observations = [(4, 3), (4, 2), (3, 2), (4, 0), (2, 0), (2, 0), (3, 2), \\n # (4, 2), (2, 3), (3, 5)]\\n num_time_steps = len(observations)\\n forward_messages = [None] * num_time_steps\\n forward_messages[0] = prior_matrix\\n # # # TODO: Compute the forward messages\\n for i,x_i in enumerate(observations):\\n if x_i:\\n obs_index = obs_state_index_map[x_i]\\n pi_0 = forward_messages[i]\\n # print(len(B[:obs_index]))\\n weights = np.multiply(pi_0, B[:,obs_index])\\n # x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\\n else:\\n weights = forward_messages[i]\\n # print(weights)\\n x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\\n if i+1 < len(forward_messages):\\n forward_messages[i+1] = x#normalize(x)\\n # break\\n\\n ## forward messages as dictionary\\n # for_dict = [None]*num_time_steps\\n # for j,f in enumerate(forward_messages):\\n # x = Distribution()\\n # for i,x_i in enumerate(f):\\n # if x_i == 0:\\n # continue\\n # # print(i,x_i)\\n # x[all_possible_hidden_states[i]] = x_i\\n # for_dict[j] = x.renormalize()\\n # print(for_dict[3])\\n\\n # print('--------------\\\\n-----------------\\\\n')\\n\\n\\n backward_messages = [None] * num_time_steps\\n # backward_messages[-1] = [1]*len(prior_matrix)\\n message = np.ones(len(all_possible_hidden_states), dtype=np.float64)\\n backward_messages[-1] = message/len(all_possible_hidden_states)\\n \\n# ****\\n ## Backwards messages\\n for i,x_i in enumerate(reversed(observations)):\\n # print(x_i)\\n if x_i:\\n obs_index = obs_state_index_map[x_i]\\n pi = backward_messages[-1-i]\\n weights = np.multiply(pi, B[:,obs_index])\\n else:\\n weights = backward_messages[-1-i]\\n # print(i)\\n x = sum([A[:,j]*w_i for j,w_i in enumerate(weights)])\\n\\n if i+1 < len(backward_messages):\\n backward_messages[-2-i] = x#normalize(x)\\n\\n ## backward messages as dictionary\\n # back_dict = [None]*num_time_steps\\n # for j,b in enumerate(backward_messages):\\n # x = Distribution()\\n # if b == None:\\n # continue\\n # for i,x_i in enumerate(b):\\n # if x_i == 0 or x_i==None:\\n # continue\\n # # print(i,x_i)\\n # x[all_possible_hidden_states[i]] = x_i\\n # back_dict[j] = x.renormalize()\\n \\n # print(back_dict[0])\\n # print(A[:10,:10])\\n # print('\\\\n-----------------\\\\n', B[:10,:10])\\n\\n # print(backward_messages[2])\\n # backward_messages[0] = forward_messages[0]\\n # # ## marginals as matrix\\n marginals = [None] * num_time_steps \\n for i,x_i in enumerate(observations):\\n if x_i:\\n obs_index = obs_state_index_map[x_i]\\n marginals[i] = np.multiply(np.multiply(backward_messages[i],\\n forward_messages[i]),\\n B[:,obs_index])\\n else:\\n marginals[i] = np.multiply(backward_messages[i],forward_messages[i])\\n # if i == 0:\\n # marginals[i] = np.multiply(backward_messages[i], B[:,obs_index])\\n # elif i == len(observations)-1:\\n # marginals[i] = np.multiply(forward_messages[i], B[:,obs_index])\\n # else:\\n\\n ## marginals as dictionary\\n marg_dict = [None]*num_time_steps\\n for j,m in enumerate(marginals):\\n x = Distribution()\\n for i,x_i in enumerate(m):\\n if x_i == 0 or x_i==None:\\n continue\\n x[all_possible_hidden_states[i]] = x_i\\n marg_dict[j] = x.renormalize()\\n # print(marginals[i])\\n # print(A[:10, :10], '\\\\n')\\n # print(B[:10, :10], '\\\\n')\\n # print(marg_dict)\\n return marg_dict\",\n \"def detach_hidden(hidden: Any) -> Any:\\n return apply_to_tensor(hidden, Tensor.detach)\",\n \"def hidden_layers(self):\\n\\t\\tif self.hidden is None:\\n\\t\\t\\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\\n\\t\\t\\tlast_hidden = self.x\\n\\t\\t\\tif self.covnet == 1:\\n\\t\\t\\t\\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\\n\\t\\t\\telif self.covnet == 2:\\n\\t\\t\\t\\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\\n\\t\\t\\t\\t self.layerSize[0], self.layerSize[1])\\n\\t\\t\\telse:\\n\\n\\t\\t\\t\\tself._drouput = 'dr'\\n\\t\\t\\t\\t# self.hidden.append(self.x)\\n\\t\\t\\t\\tfor i in range(1, len(self.all_layer_sizes)):\\n\\t\\t\\t\\t\\tname_scope = 'hidden' + str(i - 1)\\n\\t\\t\\t\\t\\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\\n\\t\\t\\t\\t\\tactivation_function = self.activation_function\\n\\t\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\\n\\t\\t\\t\\t\\t last_hidden)\\n\\t\\t\\t\\tname_scope = 'final_layer'\\n\\t\\t\\t\\trow_size, col_size = self.layerSize[-1], self.num_of_classes\\n\\t\\t\\t\\tactivation_function = None\\n\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\\n\\t\\treturn self.hidden\",\n \"def backward(self, top, propagate_down, bottom):\\r\\n pass\",\n \"def init_hidden(self):\\n pass\",\n \"def init_hidden(self):\\n pass\",\n \"def _hidden_activation(self, inputs):\\n if self.act_enc is None:\\n act_enc = lambda x: x\\n else:\\n act_enc = self.act_enc\\n return act_enc(self._mappings(inputs))\",\n \"def forward(self)->None:\",\n \"def transparent_forward(self, inp, hidden=None, give_gates=False, debug=False):\\n\\n lseq = inp.shape[0]\\n nseq = inp.shape[1]\\n # ispad = (input == self.padding)\\n\\n if hidden is None:\\n hidden = self.init_hidden(nseq)\\n\\n H = torch.zeros(lseq, self.nhid, nseq)\\n if give_gates:\\n Z = torch.zeros(lseq, self.nhid, nseq)\\n R = torch.zeros(lseq, self.nhid, nseq)\\n \\n # because pytorch only returns hidden activity in the last time step,\\n # we need to unroll it manually. \\n O = torch.zeros(lseq, nseq, self.decoder.out_features)\\n if self.recoder is None:\\n emb = inp\\n else:\\n emb = self.recoder(inp)\\n for t in range(lseq):\\n if give_gates:\\n out, hidden, ZR = self.rnn(emb[t:t+1,...], hidden, give_gates=True)\\n Z[t,:,:] = ZR[0].squeeze(0).T\\n R[t,:,:] = ZR[1].squeeze(0).T\\n else:\\n out, hidden = self.rnn(emb[t:t+1,...], hidden)\\n dec = self.decoder(out)\\n # naan = torch.ones(hidden.squeeze(0).shape)*np.nan\\n # H[t,:,:] = torch.where(~ispad[t:t+1,:].T, hidden.squeeze(0), naan).T\\n H[t,:,:] = hidden.squeeze(0).T\\n O[t,:,:] = dec.squeeze(0)\\n\\n if give_gates:\\n if debug:\\n return O, H, Z, R, emb\\n else:\\n return O, H, Z, R\\n else:\\n if debug:\\n return O, H, emb\\n else:\\n return O, H\",\n \"def act(self, state):\\n return\",\n \"def forward_backward(self, x):\\n observation_log_probs = self._observation_log_probs(x, mask=None)\\n with tf.name_scope('forward_belief_propagation'):\\n self.forward_log_probs = self._forward(observation_log_probs)\\n\\n with tf.name_scope('backward_belief_propagation'):\\n self.backward_log_probs = self._backward(observation_log_probs)\",\n \"def init_hidden_state(self, batch_size):\\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\\n return h, c\",\n \"def init_hidden_state(self, batch_size):\\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\\n return h, c\",\n \"def init_hidden_state(self, batch_size):\\n h = torch.zeros(batch_size, self.decoder_dim).to(device) # (batch_size, decoder_dim)\\n c = torch.zeros(batch_size, self.decoder_dim).to(device)\\n return h, c\",\n \"def _localSetState(self,pdict):\\n super()._localSetState(pdict)\\n self.transition = pdict.pop('transition')\\n self.steadyStatePb = pdict.pop('steadyStatePb')\",\n \"def is_hidden():\\n return False\",\n \"def is_hidden():\\n return False\",\n \"def forward(self):\\n pass\",\n \"def forward(self):\\n pass\",\n \"def transparent_forward(self, input, hidden, give_gates=False, debug=False):\\n\\n lseq, nseq = input.shape\\n ispad = (input == self.padding)\\n\\n H = torch.zeros(lseq, self.nhid, nseq)\\n if give_gates:\\n Z = torch.zeros(lseq, self.nhid, nseq)\\n R = torch.zeros(lseq, self.nhid, nseq)\\n \\n # because pytorch only returns hidden activity in the last time step,\\n # we need to unroll it manually. \\n O = torch.zeros(lseq, nseq, self.decoder.out_features)\\n emb = self.encoder(input)\\n for t in range(lseq):\\n if give_gates:\\n out, hidden, ZR = self.rnn(emb[t:t+1,...], hidden, give_gates=True)\\n Z[t,:,:] = ZR[0].squeeze(0).T\\n R[t,:,:] = ZR[1].squeeze(0).T\\n else:\\n out, hidden = self.rnn(emb[t:t+1,...], hidden)\\n dec = self.decoder(out)\\n # naan = torch.ones(hidden.squeeze(0).shape)*np.nan\\n # H[t,:,:] = torch.where(~ispad[t:t+1,:].T, hidden.squeeze(0), naan).T\\n H[t,:,:] = hidden.squeeze(0).T\\n O[t,:,:] = dec.squeeze(0)\\n\\n if give_gates:\\n if debug:\\n return O, H, Z, R, emb\\n else:\\n return O, H, Z, R\\n else:\\n if debug:\\n return O, H, emb\\n else:\\n return O, H\",\n \"def hidden_singles(self):\\n self.change = True\\n while self.change:\\n self.hidden_round()\",\n \"def forward(self, input, hidden, give_gates=False, debug=False):\\n\\n emb = self.encoder(input)\\n if emb.dim()<3:\\n emb = emb.unsqueeze(0)\\n\\n if give_gates:\\n output, hidden, extras = self.rnn(emb, hidden, give_gates)\\n else:\\n output, hidden = self.rnn(emb, hidden)\\n\\n # decoded = self.softmax(self.decoder(output))\\n decoded = self.decoder(output)\\n\\n if give_gates:\\n if debug:\\n return decoded, hidden, extras, emb\\n else:\\n return decoded, hidden, extras\\n else:\\n if debug:\\n return decoded, hidden, emb\\n else:\\n return decoded, hidden\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69670856","0.6397652","0.6265983","0.6238433","0.61677355","0.61020136","0.60459715","0.60427034","0.6039696","0.5999765","0.5988221","0.598384","0.5973033","0.5929639","0.591734","0.5909836","0.5899876","0.58930695","0.58797956","0.5878488","0.58754236","0.58631843","0.5860396","0.582561","0.5799732","0.5798763","0.57897353","0.57803786","0.57696754","0.5754079","0.5748362","0.573542","0.57326186","0.57233113","0.57233113","0.5717261","0.57026607","0.56961185","0.56830674","0.5682909","0.5682909","0.5682909","0.568004","0.567124","0.567124","0.567124","0.56624454","0.5661189","0.56564456","0.56564456","0.5640877","0.56370497","0.56370497","0.56312674","0.56237006","0.56036174","0.5599706","0.55877066","0.5586992","0.5586992","0.558346","0.558346","0.55697644","0.55647093","0.55638045","0.555131","0.5547849","0.5546529","0.5543302","0.55420804","0.5530079","0.55295277","0.552323","0.5521589","0.5514112","0.55045307","0.5504523","0.548357","0.54756135","0.54756135","0.5467778","0.5466713","0.54649705","0.5463738","0.54610234","0.5453371","0.5453371","0.5453371","0.5450528","0.5444168","0.5444168","0.54365706","0.54365706","0.54345405","0.5418065","0.54128385","0.5411881","0.5411881","0.5411881","0.5411881","0.5411881"],"string":"[\n \"0.69670856\",\n \"0.6397652\",\n \"0.6265983\",\n \"0.6238433\",\n \"0.61677355\",\n \"0.61020136\",\n \"0.60459715\",\n \"0.60427034\",\n \"0.6039696\",\n \"0.5999765\",\n \"0.5988221\",\n \"0.598384\",\n \"0.5973033\",\n \"0.5929639\",\n \"0.591734\",\n \"0.5909836\",\n \"0.5899876\",\n \"0.58930695\",\n \"0.58797956\",\n \"0.5878488\",\n \"0.58754236\",\n \"0.58631843\",\n \"0.5860396\",\n \"0.582561\",\n \"0.5799732\",\n \"0.5798763\",\n \"0.57897353\",\n \"0.57803786\",\n \"0.57696754\",\n \"0.5754079\",\n \"0.5748362\",\n \"0.573542\",\n \"0.57326186\",\n \"0.57233113\",\n \"0.57233113\",\n \"0.5717261\",\n \"0.57026607\",\n \"0.56961185\",\n \"0.56830674\",\n \"0.5682909\",\n \"0.5682909\",\n \"0.5682909\",\n \"0.568004\",\n \"0.567124\",\n \"0.567124\",\n \"0.567124\",\n \"0.56624454\",\n \"0.5661189\",\n \"0.56564456\",\n \"0.56564456\",\n \"0.5640877\",\n \"0.56370497\",\n \"0.56370497\",\n \"0.56312674\",\n \"0.56237006\",\n \"0.56036174\",\n \"0.5599706\",\n \"0.55877066\",\n \"0.5586992\",\n \"0.5586992\",\n \"0.558346\",\n \"0.558346\",\n \"0.55697644\",\n \"0.55647093\",\n \"0.55638045\",\n \"0.555131\",\n \"0.5547849\",\n \"0.5546529\",\n \"0.5543302\",\n \"0.55420804\",\n \"0.5530079\",\n \"0.55295277\",\n \"0.552323\",\n \"0.5521589\",\n \"0.5514112\",\n \"0.55045307\",\n \"0.5504523\",\n \"0.548357\",\n \"0.54756135\",\n \"0.54756135\",\n \"0.5467778\",\n \"0.5466713\",\n \"0.54649705\",\n \"0.5463738\",\n \"0.54610234\",\n \"0.5453371\",\n \"0.5453371\",\n \"0.5453371\",\n \"0.5450528\",\n \"0.5444168\",\n \"0.5444168\",\n \"0.54365706\",\n \"0.54365706\",\n \"0.54345405\",\n \"0.5418065\",\n \"0.54128385\",\n \"0.5411881\",\n \"0.5411881\",\n \"0.5411881\",\n \"0.5411881\",\n \"0.5411881\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":829,"numItemsPerPage":100,"numTotalItems":95772,"offset":82900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjA4NTk0OCwianRpIjoiY2MzMjI5MDItNjVmMy00YTVlLTkwZjAtZTYwNThlODYwN2NmIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwODk1NDgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.TirDlMYWgVThPzHfVyAPtikUIOWVm3nC8Hko3r3WWWcpXUyhyJcUELZSMStRPA3FSVk7_MjJx5NTCbkRbk-EDg","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 |
|---|---|---|---|---|---|---|
Returns the two next marks that haven't been used on this space. | def next_marks(self):
if self.n != 0:
pmax = max(self.marks)
else:
pmax = 0
p1 = pmax + 1
p2 = pmax + 2
return p1, p2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getNextTerritoryPlaceMarkerno(self):\n \n # if self.max_markerno == 0\n if self.max_markerno == 0:\n return 1\n \n # All markerno's SHOULD be number 1 through total number markers\n # if not, there are some markers that have not yet been assigned markerno\n # go ahead and set m... | [
"0.62585247",
"0.6197842",
"0.6161695",
"0.5964449",
"0.5657985",
"0.55898744",
"0.55055714",
"0.54640234",
"0.5390226",
"0.5383929",
"0.531474",
"0.52425236",
"0.52278495",
"0.51669264",
"0.5164936",
"0.51615626",
"0.51525515",
"0.51417595",
"0.5131687",
"0.5094463",
"0.5083... | 0.7172521 | 0 |
Returns the next mark that hasn't been used. | def next_mark(self):
if self.n != 0:
pmax = max(self.marks)
else:
pmax = 0
return pmax + 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_next_unmarked(self, current):\n while self.__is_multiple(current):\n current += 1\n return current",
"def _getNextTerritoryPlaceMarkerno(self):\n \n # if self.max_markerno == 0\n if self.max_markerno == 0:\n return 1\n \n # All markerno's SHOULD be num... | [
"0.7044648",
"0.6642172",
"0.62489015",
"0.62181896",
"0.61391634",
"0.60871315",
"0.60135794",
"0.59055674",
"0.57508135",
"0.5715984",
"0.5689493",
"0.5670749",
"0.5634214",
"0.56282294",
"0.5622141",
"0.5611392",
"0.5594197",
"0.5570131",
"0.5565583",
"0.55653036",
"0.5558... | 0.73365617 | 0 |
To catch a common mistake... | def __iter__(self):
raise Exception("Don't iterate this! Did you pass this to intersect without putting it in a list?") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unexpected_error(self, exception):",
"def unexpectedException(self):",
"def handle_err(self):\n pass",
"def check_errors(self) -> None:",
"def experiment3():\n raise FAKE_ERROR",
"def report_unexpected_exception(self, *args, **kwargs):\n pass",
"def error(self):\n ...",
"... | [
"0.7152382",
"0.6912902",
"0.65898734",
"0.6582553",
"0.6582474",
"0.6561996",
"0.6337797",
"0.62926984",
"0.62898856",
"0.6280134",
"0.62704444",
"0.6255637",
"0.6242657",
"0.6204336",
"0.6183122",
"0.61740494",
"0.61206454",
"0.6119092",
"0.610744",
"0.60890114",
"0.6026607... | 0.0 | -1 |
Returns a dictionary, with keys being the degrees, and values being a list of indexes of classes of the corrsponding degree. This is used by a different function to generate a list of all potentially nonzero monomials. Does not return psi classes, since they are made differently. | def degree_index_dict(self):
did = dict()
for i,c in enumerate(self.classes):
if isinstance(c, lambda_class) or isinstance(c, psi_class) or c == 0:
continue
try:
degree = c.degree
except AttributeError:
degre... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def degree_index_dict_no_red(self):\n did = dict()\n for i,c in enumerate(self.classes):\n if isinstance(c, reducible_boundary) or isinstance(c, psi_class) or c == 0:\n continue \n try:\n degree = c.degree\n except AttributeEr... | [
"0.76682293",
"0.60476583",
"0.53982973",
"0.5278339",
"0.526159",
"0.52377534",
"0.5233555",
"0.5195327",
"0.5183467",
"0.5165781",
"0.5156541",
"0.5151971",
"0.5097595",
"0.50944966",
"0.50942034",
"0.5063305",
"0.50598127",
"0.50462115",
"0.504316",
"0.50406444",
"0.502819... | 0.7501198 | 1 |
Returns a dictionary, with keys being the degrees, and values being a list of indexes of classes of the corrsponding degree. This is used by a different function to generate a list of all potentially nonzero monomials. This version does do the lambdas, but no reducible boundaries or psis. | def degree_index_dict_no_red(self):
did = dict()
for i,c in enumerate(self.classes):
if isinstance(c, reducible_boundary) or isinstance(c, psi_class) or c == 0:
continue
try:
degree = c.degree
except AttributeError:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def degree_index_dict(self):\n did = dict()\n for i,c in enumerate(self.classes):\n if isinstance(c, lambda_class) or isinstance(c, psi_class) or c == 0:\n continue \n try:\n degree = c.degree\n except AttributeError:\n ... | [
"0.72528434",
"0.5412844",
"0.5394591",
"0.53063107",
"0.5302103",
"0.52735525",
"0.526004",
"0.5210724",
"0.5204059",
"0.51863134",
"0.51816136",
"0.51750946",
"0.51374143",
"0.5130763",
"0.50688875",
"0.5054228",
"0.5043922",
"0.5026027",
"0.4983465",
"0.49790865",
"0.49574... | 0.7285419 | 0 |
Returns true if there is a forgetful map out of this space. | def not_pushed_down(self):
return (self.genus >= 2 and self.n != 0) or (self.genus == 1 and self.n > 1) or (self.genus == 0 and self.n > 3) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkMap(self):\n return True",
"def __nonzero__(self):\n\n return not ipset.ipmap_is_empty(self.map)",
"def is_empty(self):\n\n return ipset.ipmap_is_empty(self.map)",
"def is_unoccupied(self, row, col):\n return self.maze[row][col] is EMPTY",
"def is_full(self):\n i... | [
"0.67249465",
"0.66899806",
"0.66786814",
"0.6617099",
"0.65594023",
"0.6538555",
"0.65054786",
"0.64949316",
"0.6427947",
"0.6398569",
"0.63808787",
"0.6360524",
"0.63576496",
"0.6355212",
"0.6343116",
"0.6303801",
"0.62969935",
"0.62950987",
"0.6289435",
"0.6248638",
"0.619... | 0.0 | -1 |
Returns the space obtained by forgeting as many marked points as possible. | def pushed_down(self):
if self.genus == 0:
return Mgn(0,3)
if self.genus == 1:
return Mgn(1,1)
return Mgn(self.genus,0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forget(self, mark):\n return Mgn(self.genus, self.marks.difference([mark]))",
"def remaining(self):\n\t\tmines = sum(1 for _ in self.get_mines())\n\t\tmarked = sum(1 for x in range(self.width)\n\t\t\t\t\t for y in range(self.height) if self.marks[x][y] == FLAG)\n\t\treturn mines - marked",
"def ob... | [
"0.6049785",
"0.5959044",
"0.57731503",
"0.55129325",
"0.5471895",
"0.5466985",
"0.5431448",
"0.5298027",
"0.5284099",
"0.5224681",
"0.52125984",
"0.5202014",
"0.5183426",
"0.5176836",
"0.5156857",
"0.5156857",
"0.5152435",
"0.5124654",
"0.50829494",
"0.5079855",
"0.5060599",... | 0.0 | -1 |
Returns a new space with the specified point forgotten. | def forget(self, mark):
return Mgn(self.genus, self.marks.difference([mark])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lift(point):\n return gs.copy(point)",
"def clone(self):\n return Point(self.x, self.y)",
"def clone(self):\n return Point(self.x, self.y)",
"def new_position(self, p):\n if self.track:\n self.gnx = p.gnx\n else:\n p = self.get_position()\n\n ... | [
"0.6511328",
"0.5885441",
"0.5885441",
"0.5658703",
"0.5657942",
"0.5507595",
"0.5403226",
"0.5349651",
"0.5326823",
"0.53047156",
"0.53036803",
"0.52807295",
"0.5265675",
"0.5237062",
"0.5217262",
"0.519684",
"0.5185227",
"0.51527864",
"0.5148071",
"0.5139145",
"0.5123939",
... | 0.0 | -1 |
This method must be overridden. Pull this class back to the product M1 x M2, with p1 and p2 being the new marks. | def pullback_red(self, M1p1, M2p2):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mult(diagram1, diagram2):\n raise NotImplementedError",
"def product(self):\n raise NotImplementedError",
"def mult(self, other):\r\n A = np.dot(self.M, other.M)\r\n B = np.dot(self.M, other.N) + np.dot(self.N, other.M) + \\\r\n self.k*np.dot(self.N, other.N)\r\n ... | [
"0.58971804",
"0.5865411",
"0.57406694",
"0.5660099",
"0.5656148",
"0.5627505",
"0.55751514",
"0.55020183",
"0.54862946",
"0.5451903",
"0.54322046",
"0.5426278",
"0.54229295",
"0.53983384",
"0.53671396",
"0.53667814",
"0.53398585",
"0.53313184",
"0.5314007",
"0.53138614",
"0.... | 0.5742735 | 2 |
This method must be overridden. Pull back to the irreducible curve, where the class is currently on M, and p1 and p2 are the names of the new marks. | def pullback_irr(self, M, p1, p2):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pullback_red(self, M1p1, M2p2):\n pass",
"def oncurve(self, P):\n\t\traise Exception(NotImplemented)",
"def GetPoint2(self):\n ...",
"def GetPoint2(self):\n ...",
"def GetPoint1(self):\n ...",
"def GetPoint1(self):\n ...",
"def __init__(self, pt1, pt2):\n s... | [
"0.55120814",
"0.5377777",
"0.5299187",
"0.5299187",
"0.5174387",
"0.5174387",
"0.5164251",
"0.5075292",
"0.5018509",
"0.49826714",
"0.49812275",
"0.49715918",
"0.49609345",
"0.4957323",
"0.495071",
"0.49328053",
"0.49311933",
"0.4910637",
"0.48935622",
"0.48855036",
"0.48817... | 0.55004317 | 1 |
Returns a tuple that can be used to represent this class in the dictionary. It recieves as a argument a dictionary that tells you how to reindex the marks. | def table_key(self, reindex_dict):
reindexed_marks = []
for m in self.component1.marks:
new_m = reindex_dict.get(m)
if new_m == None:
if len(reindex_dict) == 0:
new_m = 0
else:
new_m = max(reindex_dict.values... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getitem__(self, index):\n if index in self.marks:\n return psi_class(self, index)\n return self.classes[index-1]",
"def key(self, x):\r\n return tuple(x)",
"def _hashable_content(self) -> Tuple[int]:\n return (self.index,)",
"def get_info_in_tuple(self):\r\n ... | [
"0.5695776",
"0.553696",
"0.5536798",
"0.55358136",
"0.5507339",
"0.5451462",
"0.5404659",
"0.5376407",
"0.5360486",
"0.5334526",
"0.5330665",
"0.53029096",
"0.528989",
"0.52669483",
"0.5261161",
"0.5231731",
"0.5197029",
"0.5193263",
"0.51903",
"0.515945",
"0.51434106",
"0... | 0.66550064 | 0 |
Returns either 1 or 2, depending on the degree of the map from the product space to this reducible boundary. It should be two if there is an automorphism of the graph, and 1 otherwise. | def degree_of_map(self):
if 2*self.component1.genus == self.space.genus and self.space.n == 0:
return 2
else:
return 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def degree(self, k):\n one_if_my_all_k = 1 if self.my_alll(k) else 0\n return (2 * self.get_prp_j(k)[0]) + one_if_my_all_k",
"def __len__(self):\n # Product function that can handle iterables (np.product can't).\n product = partial(reduce, operator.mul)\n modstr = '%s__' % self... | [
"0.56591105",
"0.55599594",
"0.55144054",
"0.54866827",
"0.54248524",
"0.5414117",
"0.5380749",
"0.53456897",
"0.5329448",
"0.53151715",
"0.53136253",
"0.5302995",
"0.5274688",
"0.52355593",
"0.52244955",
"0.52135247",
"0.52087957",
"0.5205941",
"0.52037925",
"0.51970476",
"0... | 0.7497575 | 0 |
Returns the coefficent in formula that coverts chern classes to kappas and psis (formula for chern character in [Yan10]). | def get_coeff(self):
return bernoulli(self.degree+1) / factorial(self.degree + 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def estimateCs(y, inp):\n\treturn 1 -(math.tanh(getK1(inp) - (y/getY90(inp)) / (2 * getD0(inp)) + (y/getY90(inp) - 1/3.0)**3 / (3 * getD0(inp))))**2",
"def calculate_cci(hunterlab):\n return 1000 * (hunterlab[1]) / (hunterlab[0] * hunterlab[2])",
"def cie_lab(self):\n K = Fraction(1, 3) * Fraction(29... | [
"0.6410334",
"0.62566257",
"0.6107049",
"0.60611534",
"0.60424066",
"0.583772",
"0.57275325",
"0.57261425",
"0.5708629",
"0.5658784",
"0.56464934",
"0.5640204",
"0.5634834",
"0.5633246",
"0.55867624",
"0.55810136",
"0.55681336",
"0.55570865",
"0.5538005",
"0.5534324",
"0.5521... | 0.0 | -1 |
Returns the "bad" (Mumford's original) kappa of the same degree. | def get_kappa(self):
return kappa_class(self.space, self.degree) - sum((psi_class(self.space, p)**self.degree for p in self.space.marks) ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kappa(tol_angle, degrees=True):\n if degrees:\n tol_angle = np.radians(tol_angle)\n return 4/(tol_angle**2)",
"def kappa(self):\n a, c, d, b = self.to_ccw()\n p1, q1 = a + b, c + d\n p2, q2 = a + c, b + d\n n = p1 + q1\n\n if n == 0:\n return np.nan\... | [
"0.67796105",
"0.6638783",
"0.65222853",
"0.62173575",
"0.61565024",
"0.6044664",
"0.60339195",
"0.5998601",
"0.59471756",
"0.5932053",
"0.5853644",
"0.5831035",
"0.57836586",
"0.5782085",
"0.5764921",
"0.57372206",
"0.57042474",
"0.56982696",
"0.5663674",
"0.5653718",
"0.564... | 0.70768404 | 0 |
See formula for chern character in [Yan10]. This is a generator that yeilds a tuple of data used to compute the sum over the reducible boundary pushforward maps. | def get_red_boundaries_and_psis(self,i):
for (M1,p1), (M2, p2) in self.space.red_boundaries_as_spaces():
if M1.n == 1 and M2.n == 1 and M1.genus == M2.genus:
degree_of_map = 2
else:
degree_of_map = 1
yield (M1, p1), (M2, p2), psi_class(M1, p1) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data(self) -> Generator[Tuple[int, int], None, None]:\n x = self.x_start\n y = self.y_start\n yield x, y\n while True:\n x += self.x_rate\n y += self.y_rate\n yield int(x), int(y)",
"def __call__(self,data):\n \n firstkey = True\n ... | [
"0.5973402",
"0.5613494",
"0.54590005",
"0.5422092",
"0.5411444",
"0.53831804",
"0.5371424",
"0.53577024",
"0.5354976",
"0.53450185",
"0.52727723",
"0.52123487",
"0.5203865",
"0.51984775",
"0.51908404",
"0.51864123",
"0.51547176",
"0.5124034",
"0.5121632",
"0.51133287",
"0.51... | 0.0 | -1 |
See formula for chern character in [Yan10]. This returns a tuple of data used to compute the sum over the irreducible boundary pushforward map. | def get_irr_boundary_and_psis(self, i):
M, p1, p2 = self.space.irr_boundary_as_space()
return (M, p1, p2), psi_class(M, p1) ** i * psi_class(M, p2) ** (self.degree - i - 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addition_homework(data: Iterator[str]) -> int:\n n = final_sum(data)\n return n.magnitude",
"def total(self):\n return {\n 'A': self.forward['A'] + self.reverse['A'],\n 'T': self.forward['T'] + self.reverse['T'],\n 'C': self.forward['C'] + self.reverse['C'],\n ... | [
"0.5287051",
"0.5171282",
"0.5117117",
"0.5091768",
"0.50772417",
"0.5064949",
"0.5062615",
"0.49961525",
"0.4990778",
"0.4971184",
"0.49267727",
"0.49233928",
"0.49182367",
"0.4904836",
"0.4892051",
"0.488806",
"0.48580143",
"0.48555157",
"0.48541743",
"0.4850237",
"0.483265... | 0.0 | -1 |
Returns an equivilant expression terms of chern characters. | def as_chern_chars(self):
#value = self.as_chern_chars_dict.get(self)
if True: #value == None:
#print "on space", self.space, "with lambda_", self.degree
upto = ceil(self.degree/2.0)+1
S = PowerSeriesRing(SR, "t")
f = ( sum( [fact... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compile_word(word):\r\n\r\n if word.isupper():\r\n terms = [('%s*%s' % (10**i, d)) for (i,d) in enumerate(word[::-1])]\r\n return '(' + '+'.join(terms) + ')'\r\n else:\r\n return word",
"def sanitize(formula):\n TR_UNICODE = {u\"·\": u\"*\", u\"−\": u\"-\"}\n return \"\".join... | [
"0.577644",
"0.56820256",
"0.56617486",
"0.5594537",
"0.5474107",
"0.5408417",
"0.539007",
"0.5386722",
"0.5358573",
"0.5320198",
"0.53183347",
"0.52778924",
"0.5266685",
"0.52639884",
"0.52527505",
"0.52509403",
"0.5234368",
"0.5219025",
"0.5209141",
"0.5207185",
"0.52059174... | 0.65786517 | 0 |
Handler function for hash join. | def hash_join (planNode):
operation_name = planNode.get_attr("Node Type")
operation_type = planNode.get_attr("Join Type")
cond_msg = planNode.get_attr("Hash Cond")
if operation_type != '':
operation_type += ' '
if (cond_msg):
cond_msg = ' on condition '+cond_msg
descrip... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def join(self):\n pass",
"def hash_key(self):",
"def _hexdigests(self):\n\n for algo in self.algos:\n q = self._queues[algo]\n q.put(b'') # Terminate\n self._threads[algo].join()\n assert q.empty()\n return super(MtHasher, self)._hexdigests()",
... | [
"0.5794422",
"0.5703464",
"0.5696048",
"0.5614501",
"0.5572176",
"0.5495869",
"0.54828334",
"0.5481546",
"0.54747283",
"0.5461832",
"0.5442346",
"0.5442346",
"0.5442346",
"0.5412181",
"0.5403193",
"0.5361309",
"0.5354412",
"0.5342982",
"0.533204",
"0.5304427",
"0.5287919",
... | 0.590912 | 0 |
Handler function for nested loop join. | def nested_loop(planNode):
node = planNode.get_attr("Node Type")
join_type = planNode.get_attr("Join Type")
if join_type != '':
join_type += ' '
join_filter = planNode.get_attr("Join Filter")
filter_msg = ''
if (join_filter):
filter_msg = ' on join filter '+join_filter
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def join(self):\n pass",
"def join(self):\n for t in self.created_list:\n t.join()",
"def joiner():\n for th in threads:\n th.join()\n done(process)",
"def run(self):\n self.cc_log(\"INFO\", \"Data Processing Join: Started\")\n if self.left_join... | [
"0.6358565",
"0.6278032",
"0.5571421",
"0.5554408",
"0.55250555",
"0.55180985",
"0.5479515",
"0.5351793",
"0.52703863",
"0.52608633",
"0.5218109",
"0.5128748",
"0.51163507",
"0.51048696",
"0.50975645",
"0.50968325",
"0.50797707",
"0.5073068",
"0.4993057",
"0.49908677",
"0.498... | 0.6324225 | 1 |
Handler function for merge join. | def merge_join(planNode):
cond = planNode.get_attr("Merge Cond")
cond_msg = ""
if (cond):
cond_msg += " on condition {}".format(cond)
node = planNode.get_attr("Node Type")
join_type = planNode.get_attr("Join Type")
if join_type != "":
join_type += ' '
description = "{}{... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(): #Status: WIP\r\n pass",
"def on_merge(self, to_be_merged, merge_result, context):\n pass",
"def testCorrectJoin(self):\n b_tree = OOBTree()\n b_tree.update({1: \"Monkey D. Luffy\", 2: \"Roronoa Zoro\", 3: \"Nami\"})\n failed_counter = 0\n key = 1\n data ... | [
"0.69647384",
"0.6865149",
"0.68056667",
"0.6671668",
"0.6515321",
"0.6314797",
"0.63016045",
"0.62063164",
"0.6184719",
"0.6171167",
"0.61051774",
"0.6040064",
"0.60022736",
"0.59989715",
"0.597163",
"0.5964814",
"0.59526324",
"0.59026444",
"0.58414847",
"0.5793461",
"0.5786... | 0.61107236 | 10 |
Handler function for append. | def append(planNode):
description = "append operation"
return description | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append(self, *args, **kwargs): # real signature unknown\n pass",
"def append(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\n pass",
"def append (self, item):\n pass",
"def do_append(self, level, msg, *args, **kwargs):\n record = self.log.m... | [
"0.7310906",
"0.70278627",
"0.6692309",
"0.6670054",
"0.6380898",
"0.63000864",
"0.62370366",
"0.6151141",
"0.61382455",
"0.60261387",
"0.602149",
"0.5980532",
"0.59785855",
"0.59732884",
"0.5956681",
"0.59549695",
"0.58898133",
"0.58898133",
"0.5844861",
"0.5840962",
"0.5820... | 0.52638185 | 95 |
Shuffle data and labels. | def shuffle_data(data):
idx = np.arange(len(data))
np.random.shuffle(idx)
return data[idx, ...] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shuffle_data(self):\n images = list(self.train_images)\n labels = list(self.train_labels)\n self.train_images = []\n self.train_labels = []\n\n # create list of permutated index and shuffle data accoding to list\n idx = np.random.permutation(len(labels))\n for i... | [
"0.84921646",
"0.84220874",
"0.800393",
"0.7868807",
"0.78123",
"0.7764462",
"0.7758387",
"0.77576107",
"0.77576107",
"0.77576107",
"0.76847744",
"0.7454648",
"0.74520284",
"0.7394949",
"0.7394949",
"0.73529667",
"0.72944164",
"0.7293919",
"0.7201344",
"0.7141838",
"0.7098533... | 0.6604832 | 37 |
Shuffle orders of points in each point cloud changes FPS behavior. Use the same shuffling idx for the entire batch. | def shuffle_points(batch_data):
idx = np.arange(batch_data.shape[1])
np.random.shuffle(idx)
return batch_data[:, idx, :] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:,idx,:]",
"def shuffle_points(mutated_genome,index):\n random.shuffle(mutated_genome[index][2])",
"def _shuffle_roidb_idx(self):\n self.perm = np.random.permutation(np.arange(s... | [
"0.72590023",
"0.7239251",
"0.67538834",
"0.6724801",
"0.6550845",
"0.6484533",
"0.6474677",
"0.6474677",
"0.6458041",
"0.6420625",
"0.6403558",
"0.63890237",
"0.6386616",
"0.63513637",
"0.629727",
"0.62965",
"0.6291102",
"0.6281963",
"0.62366074",
"0.62181103",
"0.6217867",
... | 0.7280055 | 0 |
Returns the PlotWidget contains in this window | def getPlotWidget(self):
return self._plot | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_widget(self):\n return self.imgwin",
"def getHistogramWidget(self):\n return self._getToolWindow()",
"def get_active_plot(self):\n for plot in list(self.plots.values()):\n canvas = plot.canvas()\n if canvas.hasFocus():\n return plot\n ret... | [
"0.70153105",
"0.6961207",
"0.6889463",
"0.6799132",
"0.67330176",
"0.65999055",
"0.65312165",
"0.65188783",
"0.6484199",
"0.64163965",
"0.6361403",
"0.6350211",
"0.6318388",
"0.6266669",
"0.62585574",
"0.61179197",
"0.60474443",
"0.6045812",
"0.60415775",
"0.60415775",
"0.60... | 0.832208 | 0 |
Set or change the database name. If 'modify' is True, then allow modifying the name to make it unique. Return the final name. Raise ValueError if name is invalid or already in use. | def set_name(self, name, modify=False):
assert not hasattr(self, "_dbcnx") # Must be done before any write ops.
if name == self.db.get("name"):
return
if not constants.NAME_RX.match(name):
raise ValueError("invalid database name")
if modify:
modified ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_name(name=False):\n if not name:\n name = name_generator()\n return name",
"def set_name(self, newname=\"\"):\n self.name = newname",
"def name(self, new_name: str) -> None:\n raise NotImplementedError()",
"def new_name(self,new_name):\n self.name = new_name",
"def... | [
"0.63189477",
"0.6314735",
"0.6165321",
"0.61172503",
"0.60988",
"0.60660833",
"0.6036501",
"0.6013789",
"0.600955",
"0.600955",
"0.5947962",
"0.59277517",
"0.59162265",
"0.5903049",
"0.5815733",
"0.58009654",
"0.5748256",
"0.5719417",
"0.5719417",
"0.56806755",
"0.5662065",
... | 0.8319422 | 0 |
Set to 'readonly' (True) or 'readwrite' (False). If 'readonly', then compute the hash values, else remove them. | def set_readonly(self, mode):
if self.db["readonly"] == mode:
return
self.db["readonly"] = self.readonly = mode
if mode:
hashes = {}
for hashname in flask.current_app.config["CONTENT_HASHES"]:
hashes[hashname] = hashlib.new(hashname)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readonly(self, readonly):\n\n self._readonly = readonly",
"def readonly(self, readonly):\n\n self._readonly = readonly",
"def read_only(self, read_only):\n\n self._read_only = read_only",
"def read_only(self, read_only):\n\n self._read_only = read_only",
"def readonly(self):... | [
"0.6958146",
"0.6958146",
"0.6554565",
"0.6554565",
"0.65188134",
"0.65188134",
"0.63850576",
"0.63573664",
"0.62068427",
"0.61874276",
"0.61058474",
"0.60293335",
"0.5890427",
"0.5875915",
"0.5808903",
"0.5753325",
"0.5687405",
"0.56783015",
"0.567108",
"0.56515807",
"0.5631... | 0.6786981 | 2 |
Create and load table from records (lists of data items). Infer table column types and constraints from records contents. Raises ValueError or sqlite3.Error if any problem. | def create_table_load_records(self, tablename, records, has_header=True):
# Column names from header, or make up.
if has_header:
header = records.pop(0)
header = [utils.name_cleaned(n) for n in header]
if len(header) != len(set(header)):
raise ValueErr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(cursor, table, *args, **kwds):\n try:\n records, = args\n columns = None\n except ValueError:\n columns, records = args\n\n default = kwds.pop('default', '')\n if kwds:\n msg = 'load_data() got unexpected keyword argument {0!r}'\n raise TypeError(msg.for... | [
"0.66279644",
"0.6479597",
"0.6434635",
"0.6011159",
"0.6007939",
"0.5869238",
"0.58558583",
"0.58282346",
"0.57568645",
"0.5747565",
"0.5666356",
"0.555702",
"0.5545761",
"0.55447066",
"0.5540246",
"0.5536555",
"0.5501205",
"0.5488088",
"0.54878986",
"0.5467272",
"0.54550296... | 0.762297 | 0 |
Create the table in the database and add to the database definition. If 'query' is given, do 'CREATE TABLE AS', and fix up the schema. If 'create' is True, then actually create the table. Raises ValueError if there is a problem with the input schema data. Raises SystemError if the query is interrupted by timeout. | def add_table(self, schema, query=None, create=True):
if not constants.NAME_RX.match(schema["name"]):
raise ValueError("invalid table name")
if utils.name_in_nocase(schema["name"], self.db["tables"]):
raise ValueError("name is already in use for a table")
if utils.name_in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_sql_table(self, query):\n table_pattern = r\"CREATE TABLE ([\\w_:]+)\"\n match = re.search(table_pattern, query, re.IGNORECASE)\n table_name = match.group(1)\n if \":\" in table_name:\n query = self.clean_table_name(query, table_name)\n\n # Check to see if t... | [
"0.72810155",
"0.6941827",
"0.65274644",
"0.64704907",
"0.6371803",
"0.63551843",
"0.63226044",
"0.62900233",
"0.6281851",
"0.62293935",
"0.62046564",
"0.61940694",
"0.6184373",
"0.6161017",
"0.6122502",
"0.6103641",
"0.6048098",
"0.60406506",
"0.602241",
"0.6019121",
"0.6005... | 0.74015164 | 0 |
Add the given column to the table described by the schema. Raise ValueError if there is any problem. | def add_table_column(self, schema, column):
if not column["name"] or not constants.NAME_RX.match(column["name"]):
raise ValueError("invalid column name")
if utils.name_in_nocase(column["name"], [c["name"] for c in schema["columns"]]):
raise ValueError("non-unique column name")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_column(self, table_name: str, column) -> None:\n sql = 'ALTER TABLE ' + table_name + ' ADD COLUMN ' + column.to_sql()\n self.cursor.execute(sql)",
"def add_column_to_staging_table(cursor,table_schema,table_name,column_name):\n if not check_if_column_exists(cursor, table_schema, table_name,... | [
"0.7461268",
"0.70328975",
"0.7005947",
"0.6832318",
"0.6706952",
"0.6699322",
"0.66819566",
"0.66518646",
"0.66147494",
"0.6606529",
"0.6585268",
"0.6562195",
"0.6534154",
"0.64950705",
"0.64822",
"0.64128786",
"0.6389013",
"0.6368527",
"0.62607074",
"0.6210972",
"0.6156823"... | 0.8124627 | 0 |
Create a view in the database and add to the database definition. If 'create' is True, then actually create the view. Raises ValueError if there is a problem with the input schema data. | def add_view(self, schema, create=True):
if not constants.NAME_RX.match(schema["name"]):
raise ValueError("invalid view name")
if utils.name_in_nocase(schema["name"], self.db["tables"]):
raise ValueError("name is already in use for a table")
if utils.name_in_nocase(schema... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_view(self, repo, view, sql):\n return self.user_con.create_view(\n repo=repo, view=view, sql=sql)",
"def creates_view(self):\n return self.statements[0].creates_view()",
"def create_view(self, start: int = 0, stop: int = 0):\n stmt = f\"\"\"create or replace view {sel... | [
"0.7217368",
"0.656495",
"0.63287896",
"0.6194457",
"0.6177249",
"0.6164981",
"0.60936546",
"0.6083409",
"0.606832",
"0.5918686",
"0.5900394",
"0.57855225",
"0.57373005",
"0.5719429",
"0.5673319",
"0.5611739",
"0.55860096",
"0.5470929",
"0.5427602",
"0.5407982",
"0.5404273",
... | 0.7786582 | 0 |
Check the validity of the metadata for the database. Return False if no metadata (i.e. not a DbShare file), else True. Raises ValueError or sqlite3.Error if any problem. | def check_metadata(self):
sql = f"SELECT COUNT(*) FROM {constants.TABLES}"
if self.dbcnx.execute(sql).fetchone()[0] == 0:
return False # No metadata; skip.
sql = f"SELECT name FROM {constants.TABLES}"
tables1 = [r[0] for r in self.dbcnx.execute(sql)]
sql = "SELECT na... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check(self):\n # validate contents still to do - for now just check if it exists\n return os.path.exists(self.getDefaultDatabaseConnectionParameter()['path'])",
"def db_exists(self, db):\n # HDF5 is file based\n return os.path.isfile(db)",
"def _metadata_is_consistent(metadata):... | [
"0.6685639",
"0.66693676",
"0.6632217",
"0.6471173",
"0.6443462",
"0.63612366",
"0.6281263",
"0.6280908",
"0.62710387",
"0.62230617",
"0.6158644",
"0.614975",
"0.6114387",
"0.60799456",
"0.6042524",
"0.60312736",
"0.59899956",
"0.59632313",
"0.59618896",
"0.5924156",
"0.59134... | 0.81981516 | 0 |
Return the database metadata for the given name. Return None if no such database. | def get_db(name, complete=False):
cursor = flask.g.syscnx.cursor()
sql = (
"SELECT owner, title, description, public, readonly,"
" created, modified FROM dbs WHERE name=?"
)
cursor.execute(sql, (name,))
rows = cursor.fetchall()
if len(rows) != 1:
return None # 'rowcount'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_database(self, name):\n try:\n return [db for db in self.list_databases()\n if db.name == name][0]\n except IndexError:\n raise exc.NoSuchDatabase(\"No database by the name '%s' exists.\" %\n name)",
"def get_database(self, instanc... | [
"0.7327657",
"0.722267",
"0.7001932",
"0.6679206",
"0.6602514",
"0.63183403",
"0.6302966",
"0.6268658",
"0.6256726",
"0.6192925",
"0.618651",
"0.6170439",
"0.61583745",
"0.6127866",
"0.61237854",
"0.6119",
"0.60515904",
"0.60427445",
"0.6033482",
"0.6029815",
"0.6027621",
"... | 0.6671863 | 4 |
Get the schema of the table or view. Add a member 'type' denoting which it is. Raise ValueError if no such table or view. | def get_schema(db, sourcename):
try:
schema = db["tables"][sourcename]
schema["type"] = constants.TABLE
except KeyError:
try:
schema = db["views"][sourcename]
schema["type"] = constants.VIEW
except KeyError:
raise ValueError("no such table/view... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _schema_type(self) -> Optional[type]:\n return IndexSchema",
"def _schema_type(self) -> Optional[type]:\n pass",
"def _schema_type(self) -> Optional[type]:\n return PanelSchema",
"def _schema_type(self) -> Optional[type]:\n return MovieSchema",
"def _schema_type(self) -> Opt... | [
"0.67394197",
"0.64360523",
"0.642696",
"0.6404674",
"0.63924086",
"0.6387125",
"0.63536716",
"0.6310814",
"0.62644035",
"0.6218083",
"0.6200075",
"0.61655676",
"0.6131771",
"0.6125235",
"0.601341",
"0.59711987",
"0.5944062",
"0.58982587",
"0.5890849",
"0.5876796",
"0.587585"... | 0.7271602 | 0 |
Return SQL to create a table given by its schema. Raise ValueError if any problem. | def get_sql_create_table(schema, if_not_exists=False):
if not schema.get("name"):
raise ValueError("no table name defined")
if not schema.get("columns"):
raise ValueError("no columns defined")
names = set()
for column in schema["columns"]:
if utils.name_in_nocase(column["name"], ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_table(self, schema, table):\n fields = \", \".join([\" \".join(t) for t in zip(self.schemas[schema][table][0], self.schemas[schema][table][1])])\n sql = f'set role {self.write_role}; ' \\\n + f'CREATE TABLE IF NOT EXISTS {schema}.{table} ( {fields} );'\n return sql",
"... | [
"0.7396332",
"0.7222839",
"0.7214331",
"0.719338",
"0.7181155",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7175187",
"0.7173953",
"0... | 0.77022225 | 0 |
Return SQL to create an index given by its schema. Raise ValueError if any problem. | def get_sql_create_index(tablename, schema, if_not_exists=False):
if not schema.get("columns"):
raise ValueError("no columns defined")
if len(schema["columns"]) != len(set(schema["columns"])):
raise ValueError("same column given more than once")
sql = ["CREATE"]
if schema.get("unique"):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_sql(self, model, schema_editor, using='', **kwargs):\n include = [model._meta.get_field(field_name).column for field_name in self.include]\n condition = self._get_condition_sql(model, schema_editor)\n if self.expressions:\n index_expressions = []\n for expressi... | [
"0.72072047",
"0.706101",
"0.6861405",
"0.64765775",
"0.64105004",
"0.63790756",
"0.6371936",
"0.6313902",
"0.6216902",
"0.61960846",
"0.61543465",
"0.61295676",
"0.6011166",
"0.600814",
"0.5993174",
"0.5950828",
"0.5849119",
"0.5826671",
"0.5727391",
"0.56642616",
"0.5639990... | 0.7434653 | 0 |
Get the connection for the database given by name. | def get_cnx(dbname, write=False):
try:
if write == flask.g.dbwrite:
return flask.g.dbcnx
else:
flask.g.dbcnx.close()
except AttributeError:
pass
flask.g.dbcnx = utils.get_cnx(dbname, write=write)
flask.g.dbname = dbname
flask.g.dbwrite = write
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_database(conn, name):\n\n if conn.hasDatabase(name) is False:\n return conn.createDatabase(name)\n\n return conn[name]",
"def connection(self, name=None):\n if not name:\n name = threading.currentThread().getName()\n if name in self:\n return self[name]\n self[name] = self... | [
"0.79389775",
"0.75319666",
"0.7517848",
"0.72717863",
"0.7117428",
"0.70957136",
"0.7020149",
"0.69911426",
"0.6988056",
"0.698185",
"0.6891314",
"0.68769324",
"0.68455476",
"0.6843064",
"0.6816855",
"0.67779374",
"0.6772218",
"0.67668045",
"0.67563635",
"0.67541003",
"0.672... | 0.0 | -1 |
Get the database and check that the current user has read access. Optionally add nrows for each table and view. Raise KeyError if no such database. Raise ValueError if may not access. | def get_check_read(dbname, nrows=False, complete=True):
db = get_db(dbname, complete=complete)
if db is None:
raise KeyError("no such database")
if not has_read_access(db):
raise ValueError("may not read the database")
set_nrows(db, targets=nrows)
return db | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_read(self, db, randomize_access=False):\n self.db = db\n self.randomize_access = randomize_access\n self.can_read = True",
"def db_for_read(self, model, **hints):\n if self.isAdminApp(model):\n return 'auth_db'\n return None",
"def raise_for_access(\n ... | [
"0.61900944",
"0.5673167",
"0.5670762",
"0.56600416",
"0.5628751",
"0.56280935",
"0.5595738",
"0.55469775",
"0.545015",
"0.53966767",
"0.5375409",
"0.53170985",
"0.5258059",
"0.5160819",
"0.5094779",
"0.5073889",
"0.5005565",
"0.49983191",
"0.49965835",
"0.4994591",
"0.496552... | 0.7279948 | 0 |
Get the database and check that the current user has write access. Optionally add nrows for each table and view. Raise KeyError if no such database. Raise ValueError if may not access. | def get_check_write(dbname, check_mode=True, nrows=False, complete=True):
db = get_db(dbname, complete=complete)
if db is None:
raise KeyError("no such database")
if not has_write_access(db, check_mode=check_mode):
raise ValueError("may not write to the database")
set_nrows(db, targets=n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_check_read(dbname, nrows=False, complete=True):\n db = get_db(dbname, complete=complete)\n if db is None:\n raise KeyError(\"no such database\")\n if not has_read_access(db):\n raise ValueError(\"may not read the database\")\n set_nrows(db, targets=nrows)\n return db",
"def _... | [
"0.62008744",
"0.5717889",
"0.5461007",
"0.54139274",
"0.5394495",
"0.53823745",
"0.5362482",
"0.53576916",
"0.5351964",
"0.5261355",
"0.51136035",
"0.4998261",
"0.4941331",
"0.4937972",
"0.49325716",
"0.48510417",
"0.4825769",
"0.48031938",
"0.47883636",
"0.47742996",
"0.476... | 0.6900375 | 0 |
Add the Sqlite3 database file present in the given open file object. If the database has the metadata of a DbShare Sqlite3 database, check it. Else if the database appears to be a plain Sqlite3 database, infer the DbShare metadata from it by inspection. 'size' is the size of the database file. Return the database dicti... | def add_sqlite3_database(dbname, infile, size):
try:
check_quota(size=size)
with DbSaver() as saver:
dbname = saver.set_name(dbname, modify=True)
with open(utils.get_dbpath(dbname), "wb") as outfile:
outfile.write(infile.read())
saver.initialize()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open(self):\n if not self.filename:\n raise ValueError(\"Can only open on-disk databases\")\n self.db = dbm.open(self.filename, \"w\") #raises anydbm.error\n try:\n if self.db[\"--Reserved--type\"] != self.type:\n raise ValueError(\"Not a %s database\" ... | [
"0.5955714",
"0.5953158",
"0.59470034",
"0.5555061",
"0.54738444",
"0.54535043",
"0.54270566",
"0.54080987",
"0.53994936",
"0.53630704",
"0.5354894",
"0.53220826",
"0.5319659",
"0.5310338",
"0.528904",
"0.52802867",
"0.52757585",
"0.52705204",
"0.5266127",
"0.52581644",
"0.52... | 0.7196136 | 0 |
Add the XLSX file workbook as a database. The worksheets are loaded as tables. 'size' is the size of the XLSX file. Return the database dictionary. Raise ValueError if any problem. | def add_xlsx_database(dbname, infile, size):
tmp = tempfile.NamedTemporaryFile(suffix=".xlsx")
tmp.write(infile.read())
tmp.seek(0)
try:
wb = openpyxl.load_workbook(tmp.name)
check_quota(size=size)
with DbSaver() as saver:
dbname = saver.set_name(dbname)
s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_xl2db(xlfilepath, sheetname, header_cols, insfunc, start_row=0):\n def is_header(row):\n hText = ('!!'.join(header_cols)).lower()\n rText = ('!!'.join([str(r) for r in row[:len(header_cols)]])).lower()\n return hText == rText\n \n #load sheet & file header\n sheet = XlShee... | [
"0.58233666",
"0.5794",
"0.54771256",
"0.5370337",
"0.5314483",
"0.52456737",
"0.5185944",
"0.5175234",
"0.5072808",
"0.50604826",
"0.5035717",
"0.5033447",
"0.50137645",
"0.50020313",
"0.49190697",
"0.49113122",
"0.4905969",
"0.48963267",
"0.48790076",
"0.48784056",
"0.48197... | 0.77125597 | 0 |
Computes the value of the Cross Entropy loss function. | def loss(self, y_true, score, pos_label=_NoValue):
if pos_label is not _NoValue:
raise ValueError("`pos_label` not supported")
score = score.atleast_2d() # Working with 2-D arrays only
p = CSoftmax().softmax(score) # SoftMax function
# find-like indexing (list of lists)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy(self):\n return self._cross_entropy_func",
"def cross_entropy_loss():\n return nn.CrossEntropyLoss()",
"def CE():\n def CE_loss(input,target):\n return nn.CrossEntropyLoss()(input.squeeze(), target)\n\n return CE_loss",
"def crossentropy_fn(args: StepFunctionArgs) ->... | [
"0.7596708",
"0.7409889",
"0.7297439",
"0.7185734",
"0.7045178",
"0.68566203",
"0.68134034",
"0.6808913",
"0.6760362",
"0.6733593",
"0.6732217",
"0.6728744",
"0.6717958",
"0.6706692",
"0.6689043",
"0.6683191",
"0.66703624",
"0.6636742",
"0.66352695",
"0.6622109",
"0.6614492",... | 0.0 | -1 |
Computes gradient of the Cross Entropy loss w.r.t.the classifier decision function corresponding to class label pos_label. | def dloss(self, y_true, score, pos_label=None):
score = score.atleast_2d() # Working with 2-D arrays only
grad = CSoftmax().softmax(score)
# we subtract -1 only to the elements equal to y_true
grad[[list(range(score.shape[0])), y_true.tolist()]] -= 1.0
# find-like indexing (l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_gradient(self,ex,pos,neg,examples):\n\n k = 2\n imposters = []\n\n distances = {}\n for other_ex in examples:\n\n #skip same example\n if ex == other_ex:\n continue\n\n #add other class to imposters\n if other_ex in ... | [
"0.6929106",
"0.66003597",
"0.6548047",
"0.6475285",
"0.63980824",
"0.63309544",
"0.63119125",
"0.6297976",
"0.6247121",
"0.62257177",
"0.62192774",
"0.6212148",
"0.6199504",
"0.6187455",
"0.6170391",
"0.6168697",
"0.6167525",
"0.61656535",
"0.61628205",
"0.61556435",
"0.6115... | 0.6393577 | 5 |
Check if the authenticated user has 'admin' or 'attendant' role If 'admin' authorize, else if 'attendant' deny access | def post(self):
data = ProductsResource.parser.parse_args()
for user in User.users:
if user.role == 'attendant' and user.username == auth.username():
return {'message': 'Not authorised to access '}, 401
if user.role == 'admin' and user.username == auth.username()... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_auth():\n if not current_user.is_authenticated:\n return render_template('401.html', base_template=appbuilder.base_template, appbuilder=appbuilder), 401\n for role in current_user.roles:\n if appbuilder.get_app.config['AUTH_ROLE_ADMIN'] == role.name:\n return None\n retu... | [
"0.7119449",
"0.68774784",
"0.6872807",
"0.6872807",
"0.6767177",
"0.6740289",
"0.67216414",
"0.6694622",
"0.66614085",
"0.65831244",
"0.6548067",
"0.6539639",
"0.6518462",
"0.651116",
"0.6498799",
"0.64806175",
"0.64806175",
"0.6465556",
"0.6463639",
"0.6463639",
"0.6443175"... | 0.0 | -1 |
Count the English words in the text. | def stats_text_en(text):
text1 = text.replace(',','').replace('.','').replace('--','').replace('*','').replace('!','') # Remove the non-English characters in the text.
text2 = text1.split() # Convert the string type to the list type.
dict = {x: text2.count(x) for x in text2} # Count the times of each word i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_words(text, words):\n count = 0\n for word in words: # probably should make words lowercase too\n if word in text.lower():\n count += 1\n return count",
"def words(text):\n text = \" \".join(text) if text else 'We are the knights who say \"NI\"!'\n xml.words(text)\n ... | [
"0.756502",
"0.7395247",
"0.732852",
"0.7287503",
"0.7223627",
"0.72082",
"0.7154964",
"0.7138416",
"0.7136877",
"0.7136265",
"0.7134452",
"0.709624",
"0.70858365",
"0.70343",
"0.7027962",
"0.70045686",
"0.68842417",
"0.68763244",
"0.68743664",
"0.6860438",
"0.6851171",
"0.... | 0.6403258 | 63 |
Count the Chinese characters in the text. | def stats_text_cn(text):
text1 = text.replace(',','').replace('.','').replace('--','').replace('*','').replace('!','') # Remove the non-Chinese characters in the text.
text2 = list(text1) # Convert the string type to the list type.
dict = {x: text2.count(x) for x in text2} # Count the times of each characte... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(text):\n return len(text)",
"def test_character_count(self):\n\t\tself.assertEqual(analyse_text(self.filename)[1], 133)",
"def getWordCharCount(w):\r\n rus = len(re.findall(r\"[а-я]\",w))\r\n eng = len(re.findall(r\"[a-z]\",w))\r\n c = len(w) \r\n return c, rus, eng",
"def test_ch... | [
"0.67015",
"0.6607649",
"0.6606629",
"0.6590809",
"0.65797144",
"0.6475554",
"0.6430852",
"0.61501974",
"0.6050413",
"0.60285336",
"0.6015077",
"0.59781206",
"0.5967439",
"0.5922929",
"0.5896226",
"0.58794916",
"0.585383",
"0.58402056",
"0.5804242",
"0.57875055",
"0.5774597",... | 0.6177398 | 7 |
Load movie details and ranking from csv file to database. | def load_movies_details():
data = pd.read_csv(CSV_PATH + MOVIES_DETAILS_CSV_NAME).T.to_dict()
#Insert directors to database
for i in range(len(data)):
director_name = data[i]['Director']
director_exist = Director.query.filter(Director.name == director_name).first()
if not director_ex... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_ratings_data(connection, csvfile):\n insert_sql = 'insert into ratings (userId, movieId, rating, timestamp) ' \\\n 'values (%s, %s, %s, %s)'\n load_data(connection, insert_sql, get_data_from_file(csvfile))",
"def load_records():\n\n with open('seed_data/records.csv', 'rb') as cs... | [
"0.7449447",
"0.7045075",
"0.697231",
"0.6925202",
"0.6890127",
"0.6758247",
"0.6721577",
"0.66272926",
"0.6552087",
"0.65332365",
"0.6506688",
"0.6401783",
"0.6366583",
"0.6349926",
"0.6347025",
"0.6312729",
"0.624575",
"0.6232512",
"0.6219035",
"0.62042195",
"0.62028986",
... | 0.77248156 | 0 |
Load movie cast from csv file to database | def load_movies_cast():
data = pd.read_csv(CSV_PATH + MOVIES_CAST_CSV_NAME).T.to_dict()
for i in range(len(data)):
name = data[i]['Cast']
cast_exist = Cast.query.filter(Cast.name == name).first()
if not cast_exist:
db.session.add(Cast(name=name))
db.session.commit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_ratings_data(connection, csvfile):\n insert_sql = 'insert into ratings (userId, movieId, rating, timestamp) ' \\\n 'values (%s, %s, %s, %s)'\n load_data(connection, insert_sql, get_data_from_file(csvfile))",
"def load_movies():\n filepath = \"./seed_data/u.item\"\n movies = o... | [
"0.6801924",
"0.67638457",
"0.6730367",
"0.65531254",
"0.6460458",
"0.6447328",
"0.64101523",
"0.6394198",
"0.63643944",
"0.6338704",
"0.629535",
"0.6241045",
"0.624032",
"0.6213262",
"0.6189707",
"0.60986936",
"0.6065023",
"0.60348296",
"0.59879386",
"0.5985728",
"0.5954525"... | 0.74498796 | 0 |
Load movie reviews to database | def load_movies_reviews():
data = pd.read_csv(CSV_PATH + MOVIES_REVIEWS_CSV_NAME).T.to_dict()
for i in range(len(data)):
movie_id = Movies.query.filter(Movies.title == data[i]['Title'].strip()).first().id
review = data[i]['Reviews'].strip()
rating = float(data[i]['Rating'])*100000
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_movies():\n print \"Movies\"\n\n # Delete all rows in table, so if we need to run this a second time,\n # we won't be trying to add duplicate users\n Movie.query.delete()\n\n # Read u.item file and insert data\n for row in open(\"seed_data/u.item\"):\n row =row.rstrip()\n\n ... | [
"0.67932075",
"0.67891663",
"0.6626961",
"0.65537125",
"0.64071196",
"0.63042593",
"0.6298705",
"0.62060344",
"0.618357",
"0.6129251",
"0.6100108",
"0.6071276",
"0.5998696",
"0.5919214",
"0.59152097",
"0.58447194",
"0.5771323",
"0.5766531",
"0.575739",
"0.5706212",
"0.5703885... | 0.8098433 | 0 |
Set path to csv files and run load functions | def run_load(rootpath):
global CSV_PATH
CSV_PATH = rootpath+'/csv_files/'
load_movies_details()
load_movies_cast()
load_movies_reviews() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadCSV(input_file):",
"def runs_loader(path):\n files = sorted(glob.glob(f\"{path}/*_runs.csv\"))\n df_lis = list(range(len(files)))\n for i, f in enumerate(files):\n try:\n df_lis[i] = pd.read_csv(f, sep=\",\", header=0)\n print('Read runs.csv\\n', f, df_lis[i].shape,\... | [
"0.69244933",
"0.67308754",
"0.67234784",
"0.6704039",
"0.6694249",
"0.66542995",
"0.66303647",
"0.6621924",
"0.66083246",
"0.6604463",
"0.6528164",
"0.64278746",
"0.6407914",
"0.6399219",
"0.63922846",
"0.63281393",
"0.631288",
"0.62899953",
"0.6281878",
"0.6277048",
"0.6274... | 0.79588497 | 0 |
Retorna un diccionario con los datasets preprocesados con los datos y dimensiones que se usaron para el entrenamiento | def get_datasets(self):
d = {
"X_train": self._X_train,
"Y_train": self._Y_train,
"X_test": self._X_test,
"Y_test": self._Y_test
}
return d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def datasets(self):\n return [Dataset.GWAS_CATALOG, Dataset.CLINVAR, Dataset.EFO]",
"def datasets(self):\n pass",
"def _make_data(self):\n pdf_datasets_all = make_pdf_datasets(self.pdf_list, self.xlims, self.ylims, self.tlims, self.dims, 9)\n self.pdf_dataset = np.concatenate(pdf_datase... | [
"0.6671411",
"0.6404104",
"0.6264915",
"0.62294483",
"0.622176",
"0.62013185",
"0.617189",
"0.61432046",
"0.6141271",
"0.6138427",
"0.6115273",
"0.60832447",
"0.607213",
"0.60291106",
"0.5988424",
"0.5970424",
"0.59659386",
"0.59249663",
"0.5911525",
"0.5902017",
"0.5898007",... | 0.6099431 | 11 |
Test generation of plot with no data. | def test_none(self):
arr = np.empty(0)
out = ternary(arr)
self.assertTrue(hasattr(out, "tax"))
self.assertEqual(
type(out.tax), pyternary.ternary_axes_subplot.TernaryAxesSubplot
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_arguments(self):\n fig = plt.figure()\n ax = fig.add_subplot(projection='ternary')\n lines = ax.plot()\n assert lines == []",
"def createBlankPlot(self):\n\n fig = plt.figure(figsize=(8,6),dpi=80)\n fig.set_facecolor('#ededed')\n \n # Fo... | [
"0.7609084",
"0.6816808",
"0.66936296",
"0.66777843",
"0.6663347",
"0.65976924",
"0.6582688",
"0.6567662",
"0.6511319",
"0.64886546",
"0.64844465",
"0.64685977",
"0.64488363",
"0.64084977",
"0.63887763",
"0.63578564",
"0.62796795",
"0.6261779",
"0.62349313",
"0.61744386",
"0.... | 0.6133566 | 22 |
Test generation of plot with one record. | def test_one(self):
arr = self.arr[0, :]
out = ternary(arr)
self.assertTrue(hasattr(out, "tax"))
self.assertEqual(
type(out.tax), pyternary.ternary_axes_subplot.TernaryAxesSubplot
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_arguments(self):\n fig = plt.figure()\n ax = fig.add_subplot(projection='ternary')\n lines = ax.plot()\n assert lines == []",
"def test_simple(make_plots=False):\n # Define the example you want to investigate:\n r1 = GeneralRandom(np.arange(10), np.ones(10), 100)\n ... | [
"0.6329359",
"0.61672544",
"0.61622024",
"0.61364275",
"0.60747933",
"0.6057145",
"0.6053245",
"0.6022652",
"0.6009944",
"0.5995569",
"0.5983206",
"0.59383214",
"0.5913021",
"0.5901215",
"0.58947605",
"0.5890802",
"0.5870688",
"0.58670944",
"0.5838515",
"0.58308023",
"0.57880... | 0.0 | -1 |
Test generation of plot with multiple records. | def test_multiple(self):
arr = self.arr
out = ternary(arr)
self.assertTrue(hasattr(out, "tax"))
self.assertEqual(
type(out.tax), pyternary.ternary_axes_subplot.TernaryAxesSubplot
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_plots(self):\n args = [\"L1\", 1126259446, 1126259478]\n pesummary_data = StrainData.fetch_open_data(*args)\n fig = pesummary_data.plot(type=\"td\")\n assert isinstance(fig, matplotlib.figure.Figure)\n fig = pesummary_data.plot(type=\"fd\")\n assert isinstance(fig... | [
"0.6692694",
"0.65136224",
"0.6225085",
"0.6177012",
"0.61736137",
"0.6115239",
"0.6057502",
"0.60464275",
"0.600434",
"0.59977597",
"0.5966004",
"0.5965175",
"0.59394974",
"0.5924932",
"0.5902497",
"0.5889018",
"0.5888861",
"0.5861486",
"0.5843025",
"0.58387065",
"0.5828392"... | 0.0 | -1 |
Test use of the plot for multiple rounds of plotting. | def test_overplotting(self):
arr = self.arr
out = ternary(arr)
self.assertTrue(hasattr(out, "tax"))
out2 = ternary(arr, ax=out)
self.assertTrue(out.tax is out2.tax) # hasn't added a new ternary axis | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_arguments(self):\n fig = plt.figure()\n ax = fig.add_subplot(projection='ternary')\n lines = ax.plot()\n assert lines == []",
"def testPlots(self):\n\t\tself.watcher.analyze(layers=[67], plot=True, randomize=True)",
"def is_plot(session_id, test_name):\n return Plot.i... | [
"0.7026185",
"0.6984847",
"0.6861085",
"0.68187106",
"0.66684294",
"0.66039294",
"0.6592579",
"0.6585846",
"0.6579815",
"0.6548062",
"0.652497",
"0.65162027",
"0.6512265",
"0.6506942",
"0.6480511",
"0.6476601",
"0.642403",
"0.6379334",
"0.6376706",
"0.6374267",
"0.63410354",
... | 0.0 | -1 |
Check than array of values specified using `c` can be used for a colormap. | def test_color_cmap_c_combination(self):
arr = self.arr
out = ternary(arr, c=np.linspace(0, 10, 10), cmap="viridis")
self.assertTrue(hasattr(out, "tax"))
self.assertEqual(
type(out.tax), pyternary.ternary_axes_subplot.TernaryAxesSubplot
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_color(c):\n\n c = asarray(c)\n if c.ndim == 1:\n c = c.flatten()\n c = c[newaxis, :]\n if c.shape[1] != 3:\n raise Exception(\"Color must have three values per point\")\n elif c.ndim == 2:\n if c.shape[1] != 3:\n raise Exception(\"Color array mus... | [
"0.7522997",
"0.6399244",
"0.6233486",
"0.61515546",
"0.5972068",
"0.5734837",
"0.5714697",
"0.57047075",
"0.56964606",
"0.5671895",
"0.5666058",
"0.5661867",
"0.5612082",
"0.5578248",
"0.5551499",
"0.5532785",
"0.5467735",
"0.5461801",
"0.54509157",
"0.5412546",
"0.5403892",... | 0.6554897 | 1 |
Open the browser with a given url | def start(self):
self.get(self.url) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open(url):\r\n webbrowser.open(url)",
"def openurl(url):\n\n # Open the URL\n webbrowser.open(url)",
"def open_browser(url):\n import webbrowser\n webbrowser.open_new(url)",
"def run(self, url=''):\n if url:\n webbrowser.open(url)",
"def open_web_browser(url: str):\n ... | [
"0.8814151",
"0.8780776",
"0.8645748",
"0.8425063",
"0.840312",
"0.82957417",
"0.8293585",
"0.8202446",
"0.8182634",
"0.807317",
"0.80227995",
"0.7954883",
"0.7889085",
"0.7871735",
"0.78659695",
"0.7851398",
"0.7782722",
"0.7771363",
"0.7704575",
"0.76670724",
"0.76348335",
... | 0.0 | -1 |
Close the browser application if teardown is True once the program is done | def __exit__(self, *args):
if self.teardown:
super().__exit__(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _shutdown_browser(self):\n if self.browser:\n self.browser.close()",
"def teardown(self):\n self.log.info('Close browser')\n self.driver.quit()",
"def shutdown(self):\n self._shutdown_browser()",
"def quit_browser(self):\n if self.browser is not None:\n ... | [
"0.76976466",
"0.7533014",
"0.7384081",
"0.7353654",
"0.722786",
"0.7147601",
"0.71396065",
"0.7132546",
"0.7085328",
"0.70720464",
"0.7060217",
"0.7022492",
"0.7019638",
"0.699221",
"0.6963776",
"0.69455135",
"0.694225",
"0.6910812",
"0.6864789",
"0.6861963",
"0.68549687",
... | 0.0 | -1 |
This method searching for the body html element, sends it to the Scraper class to find potencials popups and finally close them | def ads_breaker(self):
try:
self.find_element_by_xpath('/html/body').send_keys(Keys.ESCAPE)
return
except:
pass
html_element = self.find_element_by_xpath(
'/html/body').get_attribute('outerHTML')
soup = Scraper(html_element)
targe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close_popup_windows(chrome_driver, close_ele_class_names):\r\n\r\n for class_name in close_ele_class_names:\r\n close_ele = check_and_get_ele_by_class_name(chrome_driver, class_name) \r\n if close_ele:\r\n try:\r\n close_ele.click()\r\n time.sleep(1)\r\... | [
"0.5855956",
"0.5506015",
"0.5407686",
"0.5332533",
"0.53205526",
"0.52699345",
"0.5266626",
"0.52550715",
"0.5238747",
"0.52184844",
"0.51588637",
"0.50889885",
"0.50163907",
"0.49882764",
"0.4971992",
"0.49317858",
"0.49307364",
"0.49163505",
"0.48968342",
"0.4895865",
"0.4... | 0.5718086 | 1 |
This method find and press the button that let interact with the placeholder input | def enable_search(self):
html_element = self.find_element_by_xpath(
'/html/body').get_attribute('outerHTML')
soup = Scraper(html_element)
elms_obj = soup.find_search_enable_btn()
for tag, target in elms_obj.items():
if len(target) > 0:
for elem i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def click_button(self):\n self.q(css='div#fixture input').first.click()",
"def click_button(self):\n self.widgets.get('button').click()",
"def click_button(self):\n self.q(css='div#fixture button').first.click()",
"def OnButtonClick(self):\n self.choice()",
"def click_search_but... | [
"0.734838",
"0.67888856",
"0.6648583",
"0.6455985",
"0.63376254",
"0.6274271",
"0.62640727",
"0.62444234",
"0.6182181",
"0.6180678",
"0.61756253",
"0.6131169",
"0.612632",
"0.6001559",
"0.59794873",
"0.59794873",
"0.59244543",
"0.59162563",
"0.58898365",
"0.5882348",
"0.58800... | 0.0 | -1 |
This method writes into the placelholder input and perform the searching depends on the KeyWord | def perform_search(self):
self.implicitly_wait(5)
html_element = self.find_element_by_xpath(
'/html/body').get_attribute('outerHTML')
soup = Scraper(html_element)
target = soup.find_search_field()
for elem in target:
for attr, value in elem.items():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search(self, word):",
"def search(self, term):",
"def search(self, search):\n raise NotImplementedError",
"def search(self, key, headers=Headers()):",
"def linear_search(key, my_list):\n key = word.upper()\n my_list = dictionary_list\n if key in my_list:\n ... | [
"0.61128235",
"0.5776612",
"0.5620736",
"0.55137074",
"0.54994845",
"0.54782635",
"0.5416303",
"0.54147106",
"0.54119146",
"0.53961605",
"0.5377432",
"0.5369058",
"0.5353079",
"0.5327034",
"0.53183806",
"0.5302928",
"0.52938366",
"0.52867705",
"0.5276512",
"0.52595335",
"0.52... | 0.5663161 | 2 |
Forward method of GBasicBlock. | def forward(self, input):
x = self.conv(input)
x = self.bn(x)
out = self.act(x)
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self)->None:",
"def forward_pass(self):",
"def forward_graph(self):\n raise NotImplementedError",
"def instructions(self):\n yield self.inst\n for inst in self.arguments[:]:\n yield inst\n for basic_block in self.basic_blocks[:]:\n if basic_block.... | [
"0.5774737",
"0.555397",
"0.5548297",
"0.5543329",
"0.5361891",
"0.5327962",
"0.53224826",
"0.53224826",
"0.5233983",
"0.5172225",
"0.51550925",
"0.51550925",
"0.51550925",
"0.51463526",
"0.512089",
"0.51039046",
"0.5099798",
"0.50980735",
"0.50952184",
"0.5092311",
"0.504874... | 0.0 | -1 |
Forward method of DBlock. | def forward(self, x):
x = self.conv(x)
x = self.bn(x)
x = self.act(x)
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self)->None:",
"def forward_pass(self):",
"def forward(self):\n raise NotImplemented",
"def forward(self):\n raise NotImplemented",
"def forward(self):\n raise NotImplemented",
"def forward(self):\n pass",
"def forward(self):\n pass",
"def forward(self, ... | [
"0.65997905",
"0.64111036",
"0.6355572",
"0.6355572",
"0.6355572",
"0.62218034",
"0.62218034",
"0.6202959",
"0.59588075",
"0.5919142",
"0.5917902",
"0.5877505",
"0.5862478",
"0.58489037",
"0.58304656",
"0.58129233",
"0.58129233",
"0.5806567",
"0.57908845",
"0.5771873",
"0.571... | 0.0 | -1 |
Forward method of DBlock. | def forward(self, x):
x = self.conv(x)
x = self.bn(x)
x = self.act(x)
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self)->None:",
"def forward_pass(self):",
"def forward(self):\n raise NotImplemented",
"def forward(self):\n raise NotImplemented",
"def forward(self):\n raise NotImplemented",
"def forward(self):\n pass",
"def forward(self):\n pass",
"def forward(self, ... | [
"0.6604327",
"0.6416254",
"0.6361237",
"0.6361237",
"0.6361237",
"0.6227416",
"0.6227416",
"0.62045956",
"0.59616256",
"0.59166807",
"0.5916587",
"0.5883928",
"0.5860926",
"0.5845776",
"0.58363473",
"0.5818138",
"0.5818138",
"0.58091307",
"0.5787437",
"0.57739675",
"0.5714933... | 0.0 | -1 |
Return a list with 3 values, mean, var and standard deviation based on the input. The input is a list of lists and each list contains the value of a variable x and it's probability P(x). | def stats_disc_distr(ll):
out = sanitize_input(ll)
if out:
return out
avg = mean([l[0] for l in ll])
variance = sum([(l[0] - avg) ** 2 * l[1] for l in ll])
stddev = sqrt(variance)
return [avg, variance, stddev] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def varlist(data):\n \n Bxm=data[\"Bx\"].mean()\n Bym=data[\"By\"].mean()\n Bzm=data[\"Bz\"].mean()\n Bxsqm=(data[\"Bx\"]**2).mean()\n Bysqm=(data[\"By\"]**2).mean()\n Bzsqm=(data[\"Bz\"]**2).mean()\n Bxym=(data[\"Bx\"]*data[\"By\"]).mean()\n Bxzm=(data[\"Bx\"]*data[\"Bz\"]).mean()\n ... | [
"0.6871232",
"0.6794376",
"0.6588522",
"0.65758127",
"0.6561726",
"0.6561726",
"0.64889044",
"0.64831394",
"0.6480755",
"0.6479906",
"0.64087665",
"0.6356098",
"0.62918633",
"0.6272482",
"0.6234549",
"0.62317985",
"0.61967415",
"0.6176716",
"0.6155198",
"0.6139157",
"0.613164... | 0.5667719 | 67 |
Return an alert based on issues with dataset. Return None if no issue. | def sanitize_input(ll):
p = sum([l[1] for l in ll])
if not all([l[0] == int(l[0]) for l in ll]):
if round(p, 5) != 1:
return "It's not a valid distribution and furthermore, one or more variable value are not integers"
else:
return "All the variable values should be intege... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def alerts(self) -> 'outputs.DataConnectorDataTypeCommonResponse':\n return pulumi.get(self, \"alerts\")",
"def alerts(self) -> 'outputs.DataConnectorDataTypeCommonResponse':\n return pulumi.get(self, \"alerts\")",
"def alert(self, msg):\n raise DatacheckException(msg)",
"def test_get_al... | [
"0.5836452",
"0.5836452",
"0.57839143",
"0.5517184",
"0.550835",
"0.5453221",
"0.5443088",
"0.5355255",
"0.531749",
"0.52588034",
"0.5253947",
"0.5220902",
"0.51864874",
"0.5159308",
"0.51587635",
"0.5145311",
"0.5140701",
"0.51140285",
"0.51136297",
"0.50931454",
"0.5091789"... | 0.0 | -1 |
Initializes the `ImageSearcher` object. | def __init__(self, options: ImageSearcherOptions,
cpp_searcher: _CppImageSearcher) -> None:
# Creates the object of C++ ImageSearcher class.
self._options = options
self._searcher = cpp_searcher | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initImages(self):\n pass",
"def initImages(self):\n pass",
"def initImages(self):\n pass",
"def initialize(self):\n for path in self._paths:\n for root, dirnames, filenames in os.walk(os.path.expanduser(path)):\n if self._is_in_excluded_patterns(root)... | [
"0.6192012",
"0.6192012",
"0.6192012",
"0.5984795",
"0.59554297",
"0.5908261",
"0.58379114",
"0.5573122",
"0.54988146",
"0.54773754",
"0.5456339",
"0.54226214",
"0.5420283",
"0.5420283",
"0.5420283",
"0.54042417",
"0.5379169",
"0.5376522",
"0.53504145",
"0.53011996",
"0.52807... | 0.7267351 | 0 |
Creates the `ImageSearcher` object from a TensorFlow Lite model. | def create_from_file(
cls,
model_file_path: str,
index_file_path: Optional[str] = None) -> "ImageSearcher":
options = ImageSearcherOptions(
base_options=_BaseOptions(file_name=model_file_path),
search_options=_SearchOptions(index_file_name=index_file_path))
return cls.create_fr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_from_model_path(cls, model_path: str) -> 'FaceDetector':\n base_options = _BaseOptions(model_asset_path=model_path)\n options = FaceDetectorOptions(\n base_options=base_options, running_mode=_RunningMode.IMAGE\n )\n return cls.create_from_options(options)",
"def from_pretrained(\n ... | [
"0.58416957",
"0.57176334",
"0.5706374",
"0.54603827",
"0.54595345",
"0.5452045",
"0.5437048",
"0.5412006",
"0.53853303",
"0.5357966",
"0.53444433",
"0.53190815",
"0.53147674",
"0.5314517",
"0.53105253",
"0.5305688",
"0.5271952",
"0.51935625",
"0.5188544",
"0.51859486",
"0.51... | 0.5662296 | 3 |
Creates the `ImageSearcher` object from image searcher options. | def create_from_options(cls,
options: ImageSearcherOptions) -> "ImageSearcher":
searcher = _CppImageSearcher.create_from_options(
options.base_options.to_pb2(), options.embedding_options.to_pb2(),
options.search_options.to_pb2())
return cls(options, searcher) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, options: ImageSearcherOptions,\n cpp_searcher: _CppImageSearcher) -> None:\n # Creates the object of C++ ImageSearcher class.\n self._options = options\n self._searcher = cpp_searcher",
"def create_search_agent(opt):\n logging.info('Initializing the search engine API.... | [
"0.78471154",
"0.6055885",
"0.57526535",
"0.5699698",
"0.5563751",
"0.54936445",
"0.5071097",
"0.49560168",
"0.49559525",
"0.49472928",
"0.48358572",
"0.48286322",
"0.48202154",
"0.4785771",
"0.47675824",
"0.4759022",
"0.4755689",
"0.47328192",
"0.47293845",
"0.4693368",
"0.4... | 0.86626315 | 0 |
Search for image with similar semantic meaning. This method performs actual feature extraction on the provided image input, followed by nearestneighbor search in the index. | def search(
self,
image: tensor_image.TensorImage,
bounding_box: Optional[bounding_box_pb2.BoundingBox] = None
) -> search_result_pb2.SearchResult:
image_data = image_utils.ImageData(image.buffer)
if bounding_box is None:
search_result = self._searcher.search(image_data)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(image):\n keypoint, description = describe(image)\n # load keypoints, descriptions from mongodb\n\n bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)\n\n best_match_size = float(\"inf\")\n best_match_index = -1\n match_index = 0\n best_matches = 0\n\n for desc in descriptions:\n matches = b... | [
"0.6451769",
"0.62518466",
"0.57253426",
"0.56970763",
"0.5691431",
"0.5681311",
"0.5668041",
"0.5659972",
"0.5595712",
"0.5579953",
"0.5579004",
"0.55647737",
"0.55389416",
"0.55309933",
"0.549853",
"0.5484147",
"0.54750353",
"0.5473008",
"0.5466614",
"0.5465689",
"0.5465529... | 0.54816175 | 16 |
Gets the user info stored in the index file. | def get_user_info(self) -> str:
return self._searcher.get_user_info() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_info(self):\n response = self.query('user_info')\n return response",
"def userinfo(self):\n return self._userinfo",
"def get_users_info(): \n \n data = user_obj.get_users_info()\n return data",
"def getUserInfo(self):\r\n userJson = self.httpGet(ReaderUrl.USER_IN... | [
"0.7138062",
"0.6822024",
"0.67177176",
"0.66358757",
"0.6631659",
"0.6545722",
"0.6526983",
"0.64795595",
"0.6454526",
"0.6445177",
"0.64245903",
"0.6411693",
"0.63946784",
"0.6389253",
"0.63816994",
"0.63520616",
"0.63245225",
"0.6322499",
"0.63019735",
"0.6295263",
"0.6294... | 0.73406935 | 0 |
Parse individual XML node of tenhou mjlog. | def parse_node(tag, attrib):
attrib = _ensure_unicode(attrib)
_LG.debug('Input: %s: %s', tag, attrib)
if tag == 'GO':
data = _parse_go(attrib)
elif tag == 'UN':
if len(attrib) == 1: # Disconnected player has returned
data = _parse_resume(attrib)
tag = 'RESUME'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_mjlog(root_node, tags=None):\n parsed = []\n for node in root_node:\n if tags is None or node.tag in tags:\n parsed.append(parse_node(node.tag, node.attrib))\n if tags is None:\n return _structure_parsed_result(parsed)\n return parsed",
"def parse_data(self):\n\n ... | [
"0.63436925",
"0.5991037",
"0.589507",
"0.58766764",
"0.557865",
"0.5562476",
"0.5479781",
"0.5442065",
"0.5360911",
"0.535035",
"0.535035",
"0.5342198",
"0.53344345",
"0.5331019",
"0.5309822",
"0.5304942",
"0.52802145",
"0.5252274",
"0.524329",
"0.52382",
"0.51949924",
"0.... | 0.0 | -1 |
Add structure to parsed log data | def _structure_parsed_result(parsed):
round_ = None
game = {'meta': {}, 'rounds': []}
for item in parsed:
tag, data = item['tag'], item['data']
if tag in ['SHUFFLE', 'GO', 'UN', 'TAIKYOKU']:
game['meta'][tag] = data
elif tag == 'INIT':
if round_ is not None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse(self):\n i = 0\n while i < len(self.__lines):\n line = self.__lines[i]\n dt = re.match(r\"(\\d{4}-\\d{1,2}-\\d{1,2}\\s\\d{1,2}:\\d{1,2}:\\d{1,2})\", line)\n if not dt:\n i += 1\n continue\n log = {\n \"... | [
"0.6610051",
"0.63896686",
"0.62429035",
"0.62339944",
"0.59618556",
"0.5932174",
"0.5882088",
"0.58768266",
"0.5844139",
"0.5838278",
"0.58178926",
"0.58111024",
"0.57485765",
"0.56898296",
"0.5678948",
"0.55919254",
"0.5583621",
"0.5563657",
"0.5561133",
"0.55542564",
"0.55... | 0.0 | -1 |
Convert mjlog XML node into JSON | def parse_mjlog(root_node, tags=None):
parsed = []
for node in root_node:
if tags is None or node.tag in tags:
parsed.append(parse_node(node.tag, node.attrib))
if tags is None:
return _structure_parsed_result(parsed)
return parsed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xml_to_json(xml_doc) -> str:\n\n json_doc = \"\"\n return json.dumps(json_doc)",
"def _to_json(content):\n\t\treturn json.loads(json.dumps(xmltodict.parse(content)))",
"def xml_to_json(xml):\n\n logging.debug(\"-> xml_to_json()\")\n\n xml_as_dict = xmltodict.parse(xml)\n xml_as_json = json.d... | [
"0.6393545",
"0.6216957",
"0.6147134",
"0.59435886",
"0.55668646",
"0.54777443",
"0.54198986",
"0.52458364",
"0.5229408",
"0.5208654",
"0.51894504",
"0.5185886",
"0.5169987",
"0.516828",
"0.51137316",
"0.508911",
"0.5042797",
"0.50369984",
"0.5031812",
"0.5017571",
"0.4979799... | 0.5099465 | 15 |
Read and retrieve all genuine files from evalution key. | def eval_genuine(path):
out = []
with open(path, 'r') as fp:
for line in fp:
fields = line.rstrip().split()
ii, tt = fields[:2]
if tt == 'genuine':
out.append(ii[2:-4]) # remove 'D_' and '.wav'
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file_contents(self, key):\n f = open( os.path.join(self.file_path, '%s.xoj' % key))\n data = f.read()\n f.close()\n return data",
"def _ReadEntries(self):\n scope = {}\n filename = os.path.join(self._root_dir, self._options.entries_filename)\n if not os.path.exists(fi... | [
"0.6407927",
"0.62431353",
"0.6014391",
"0.5953875",
"0.5945899",
"0.5917298",
"0.5885158",
"0.58205056",
"0.5795418",
"0.5773138",
"0.5768724",
"0.57207376",
"0.5699629",
"0.56914234",
"0.56907296",
"0.5624163",
"0.5620057",
"0.5610694",
"0.55591106",
"0.555816",
"0.5552543"... | 0.5241684 | 63 |
Return True if `path` is pointing to a genuine audio. `evalkey` must not be empty if path points to an evaluation file. | def is_genuine(path, evalkey=None):
iid = os.path.basename(path)[:-4]
tt, ii = iid.split('_')
if tt == 'T': # training
return (int(ii) <= 1001508)
elif tt == 'D': # development
return (int(ii) <= 1000760)
elif tt == 'E': # evaluation
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def good_filepath(path):\n return str(path).endswith(\".wav\") and (not str(path).startswith(\".\"))",
"def is_valid(path):\n return (\n bool(path)\n and os.path.isabs(path)\n and os.path.exists(path)\n and (not is_apple() or path.endswith(\".dylib\"))\n )",
"def Valida... | [
"0.558747",
"0.52809876",
"0.52377313",
"0.50975066",
"0.50592226",
"0.5046655",
"0.50263387",
"0.49985436",
"0.49946505",
"0.49753332",
"0.4958943",
"0.4958355",
"0.48810974",
"0.4860872",
"0.48376176",
"0.4824684",
"0.481506",
"0.4802418",
"0.4767467",
"0.4759725",
"0.47442... | 0.7245087 | 0 |
Instantiate an ASVspoof dataset. | def __init__(self, root, partition, filt=None, read=None, transform=None):
self._evalkey = None
if partition == 'train':
root = os.path.join(root, 'ASVspoof2017_V2_train')
elif partition == 'valid':
root = os.path.join(root, 'ASVspoof2017_V2_dev')
elif partition =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, dataset):\n self._dataset = dataset",
"def __init__(self, dataset: Dataset):\n self.dataset = dataset",
"def __init__(self, data, v1, v2):\n self.data = data\n self.v1 = v1\n self.v2 = v2",
"def _create_dataset(source=''):\n return ExperimentalData... | [
"0.56661063",
"0.5572199",
"0.55397993",
"0.5510062",
"0.54108816",
"0.53719366",
"0.5366002",
"0.5346476",
"0.5346476",
"0.5341396",
"0.5331791",
"0.5322447",
"0.53083295",
"0.53056693",
"0.5285903",
"0.52816117",
"0.52505565",
"0.5217569",
"0.5214454",
"0.5191689",
"0.51868... | 0.5287663 | 14 |
Print out a summary of instantiated dataset. | def __str__(self):
genuine, replay = 0, 0,
for pp in self._filepaths:
if self.is_genuine(pp, self._evalkey):
genuine += 1
else:
replay += 1
report = """
+++++ Summary for [{}] partition [{}] +++++
Total [{}] valid fi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dataset_statistics(dataset):\n print (dataset.describe())",
"def dataset_statistics(dataset):\n print(dataset.describe())",
"def dataset_statistics(dataset):\n print(dataset.describe())",
"def print_summary(self):\n self.model.summary()",
"def printSummary(self):\n pass",
"def ... | [
"0.7620119",
"0.7570994",
"0.7570994",
"0.75312674",
"0.73672444",
"0.7157839",
"0.7076454",
"0.7031242",
"0.701747",
"0.69912547",
"0.69862425",
"0.687568",
"0.68725806",
"0.6824253",
"0.68016654",
"0.6780475",
"0.6779421",
"0.67729473",
"0.67296386",
"0.6724442",
"0.6701536... | 0.0 | -1 |
Return a list of (start, end) tuples. | def parse_regions(text):
_regions = []
region_pairs = text.strip().split(",")
for region_pair in region_pairs:
split_pair = region_pair.split("..")
start = split_pair[0]
end = split_pair[1]
_regions.append([start, end])
return _regions | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def range(self):\n return (self._start, self._end)",
"def endpoint(self):\n return (self._start, self._end)",
"def getRange (start, stop, step=1):\r\n result = [n for n in range(start, stop, step)]\r\n return result",
"def get_items(self):\n return (self._start._value, self... | [
"0.78692144",
"0.72173995",
"0.6941367",
"0.69413435",
"0.69286436",
"0.6818113",
"0.6817595",
"0.6778776",
"0.676874",
"0.6727795",
"0.6668462",
"0.6638845",
"0.6610449",
"0.66077703",
"0.6581024",
"0.6579434",
"0.65579057",
"0.65369064",
"0.6501064",
"0.64417356",
"0.642692... | 0.0 | -1 |
Loads a configuration from an environment variable pointing to a configuration file. This is basically just a shortcut with nicer | def from_envvar(self, variable_name, silent=False):
rv = os.environ.get(variable_name)
if not rv:
if silent:
return False
raise RuntimeError('The environment variable %r is not set '
'and as such configuration could not be '
'loaded. Set this variable and make it '
'point to... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_config(env_file_path: str) -> None:\n if os.path.isfile(env_file_path):\n load_dotenv(dotenv_path=env_file_path)\n else:\n logger.info(f\".env file does not exist on {env_file_path}. Loading environment variable from the machine\")",
"def load_settings(env=\"prod\"):\n global conf... | [
"0.74765843",
"0.74600065",
"0.74470395",
"0.7430562",
"0.7397101",
"0.7353322",
"0.72494924",
"0.7222283",
"0.7202781",
"0.71942145",
"0.70727456",
"0.6914294",
"0.6894895",
"0.68913084",
"0.68873185",
"0.68520534",
"0.6797871",
"0.6778612",
"0.6776017",
"0.67610717",
"0.675... | 0.7465972 | 1 |
Updates the values in the config from a Python file. This function behaves as if the file was imported as module with the | def from_pyfile(self, filename, silent=False):
d = imp.new_module('config')
d.__file__ = filename
try:
with open(filename) as config_file:
exec(compile(config_file.read(), filename, 'exec'), d.__dict__)
except IOError as e:
if silent and e.errno in (errno.ENOENT, errno.EISDIR):
return False
e.s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_from_file(self):\n config_path = os.environ.get('MINDINSIGHT_CONFIG', '')\n if not config_path:\n return\n\n config_module = None\n\n # python:full.path.for.config.module\n if config_path.startswith('python:'):\n config_module = import_module(conf... | [
"0.7930393",
"0.6657532",
"0.62681234",
"0.6265737",
"0.6235369",
"0.6214324",
"0.61882865",
"0.61763245",
"0.6150934",
"0.6121705",
"0.61105233",
"0.6064256",
"0.6056257",
"0.60427046",
"0.5996634",
"0.59717363",
"0.59664863",
"0.59571403",
"0.59542716",
"0.5950885",
"0.5936... | 0.6150592 | 9 |
Updates the values from the given object. Objects are usually either modules or classes. Just the uppercase variables in that object are stored in the config. | def from_object(self, obj):
for key in dir(obj):
if key.isupper():
self[key] = getattr(obj, key) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, obj):\n\n self.cfg.update(obj)",
"def from_object(self, obj):\n\t\tif isinstance(obj, str):\n\t\t\tobj = import_string(obj)\n\t\tfor key in dir(obj):\n\t\t\tif key.isupper():\n\t\t\t\tself[key] = getattr(obj, key)",
"def update(self, env_obj):\n if env_obj:\n if isinst... | [
"0.6770962",
"0.67110604",
"0.6181471",
"0.61151075",
"0.58846617",
"0.5866331",
"0.576626",
"0.5695668",
"0.56116134",
"0.56006634",
"0.5585324",
"0.5553532",
"0.5518967",
"0.5508411",
"0.5482127",
"0.5482127",
"0.53774625",
"0.5366863",
"0.5363507",
"0.5338579",
"0.53357744... | 0.63983315 | 2 |
Updates the values in the config from a JSON file. This function behaves as if the JSON object was a dictionary and passed ot the | def from_json(self, filename, silent=False):
try:
with open(filename) as json_file:
obj = json.loads(json_file.read())
except IOError as e:
if silent and e.errno in (errno.ENOENT, errno.EISDIR):
return False
e.strerror = 'Unable to load configuration file (%s)' % e.strerror
raise
for key in o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def config_from_json(self, filename):\n with open(filename, 'r') as f:\n config = json.load(f)\n config = self._process_config_imports(config)\n self.config.update(config)",
"def update(self, json_path):\n with open(json_path) as f:\n params = json.load(f)\n ... | [
"0.76795405",
"0.75639147",
"0.75639147",
"0.75639147",
"0.75639147",
"0.75639147",
"0.75639147",
"0.72586745",
"0.6951214",
"0.69304234",
"0.6862702",
"0.67505485",
"0.67290086",
"0.6702236",
"0.66978353",
"0.66320515",
"0.6591957",
"0.65346813",
"0.6519624",
"0.65131783",
"... | 0.6561453 | 17 |
Function to to import data into customer table and return success and error count for inserts | def import_customers(input_data):
error_count = 0
insert_count = 0
LOGGER.info('Starting Customer import')
for onecust in input_data:
try:
Customer(onecust['user_id'], onecust['first_name'], onecust['last_name'],
onecust['address'], onecust['phone_number'], onecu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_import(self):\n\n database.delete_database()\n\n #Fully successful import\n actual_tuples1 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\n 'rentals_data.csv')\n expected_tuples1 = ((1, 1, 1), (0, 0, 0))\n ... | [
"0.6880175",
"0.6587729",
"0.6475325",
"0.63756824",
"0.635704",
"0.61101794",
"0.59374183",
"0.59222734",
"0.584351",
"0.57974064",
"0.5794389",
"0.5749154",
"0.5666902",
"0.56425035",
"0.56202424",
"0.5606056",
"0.5592512",
"0.5570438",
"0.5553956",
"0.5546706",
"0.5538326"... | 0.78119606 | 0 |
Function to to import data into products table and return success and error count for inserts | def import_products(input_data):
error_count = 0
insert_count = 0
LOGGER.info('Starting product import')
for oneprod in input_data:
try:
Product(oneprod['product_id'], oneprod['description'], oneprod['product_type'],
oneprod['quantity']).save(full_clean=True, forc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_import(self):\n\n database.delete_database()\n\n #Fully successful import\n actual_tuples1 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\n 'rentals_data.csv')\n expected_tuples1 = ((1, 1, 1), (0, 0, 0))\n ... | [
"0.7205454",
"0.6843036",
"0.6732004",
"0.6323785",
"0.625654",
"0.62170696",
"0.6186297",
"0.61729926",
"0.61049217",
"0.6082726",
"0.60693866",
"0.6066227",
"0.6065975",
"0.6064503",
"0.60631615",
"0.5999859",
"0.5967927",
"0.5964014",
"0.59577274",
"0.5945393",
"0.59418017... | 0.79316103 | 0 |
Function to to import data into rental table and return success and error count for inserts | def import_rentals(input_data):
error_count = 0
insert_count = 0
LOGGER.info('Starting rental import')
for onerent in input_data:
try:
Rental(onerent['rental_id'], onerent['user_id'], onerent['product_id']).save(full_clean=True,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_import(self):\n\n database.delete_database()\n\n #Fully successful import\n actual_tuples1 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\n 'rentals_data.csv')\n expected_tuples1 = ((1, 1, 1), (0, 0, 0))\n ... | [
"0.62678164",
"0.62354636",
"0.62039506",
"0.61935264",
"0.6193359",
"0.6156778",
"0.6081947",
"0.5987708",
"0.59412384",
"0.57262313",
"0.5705593",
"0.5682023",
"0.5644518",
"0.562816",
"0.5627879",
"0.56163913",
"0.55966115",
"0.55852526",
"0.5581225",
"0.5578956",
"0.55618... | 0.7651243 | 0 |
Reads a csv file and return a list of dictionary objects from the file | def read_csv_file(in_file):
out_list = []
with open(in_file, 'r', newline='') as p_file:
file_list = csv.DictReader(p_file, delimiter=',')
for row in file_list:
out_list.append(row)
return out_list
#thequeue.put(out_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv(path: str) -> list[dict[str, str]]:\n with open(path, 'r') as f:\n return list(csv.DictReader(f))",
"def _read_csv_to_dictionary_list(file_name):\n catalog_list = []\n with open(file_name) as csvfile:\n reader = csv.DictReader(csvfile)\n for item in reader:\n catal... | [
"0.8055223",
"0.7994276",
"0.7939735",
"0.77738434",
"0.769351",
"0.766648",
"0.76644385",
"0.76583725",
"0.7640625",
"0.7617462",
"0.75656545",
"0.75031126",
"0.74916476",
"0.7490433",
"0.74514294",
"0.7429478",
"0.7425645",
"0.7415221",
"0.7412361",
"0.7407528",
"0.74033254... | 0.65221894 | 96 |
This function takes a directory name three csv files as input, one with product data, one with customer data and the third one with rentals data and creates and populates a | def import_data(directory_name, product_file, customer_file, rentals_file):
start = time.time()
prdt_file = os.path.join(directory_name, product_file)
cust_file = os.path.join(directory_name, customer_file)
rent_file = os.path.join(directory_name, rentals_file)
csvfiles = [prdt_file, cust_file, ren... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def import_data(dir_name, product_file, customer_file, rentals_file):\n client = MongoDBConnection()\n with client:\n LOGGER.info('Create A MongoDB database')\n hp_norton_db = client.connection.rental\n hp_norton_db.products.drop()\n hp_norton_db.customers.drop()\n hp_norto... | [
"0.737858",
"0.7335672",
"0.7120314",
"0.70489734",
"0.6846601",
"0.67960274",
"0.6598609",
"0.6519752",
"0.64735085",
"0.6414777",
"0.6379199",
"0.61592174",
"0.602735",
"0.5910841",
"0.5905573",
"0.58653945",
"0.58278537",
"0.5777576",
"0.5713795",
"0.5705191",
"0.5682086",... | 0.6151677 | 12 |
Transforms a code block into another one to show the connections | def transform_code(self, start, end, mat, highlight=True):
def elms(item, coord):
return item[coord[0]][coord[1]] if isinstance(coord, tuple) else item[coord]
for entry in mat:
if highlight:
instantiate_highlight = SurroundingRectangle(elms(start, entry[0][0]), bu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def code():",
"def _wrap_code(self, inner):\r\n yield 0, \"<code>\"\r\n for tup in inner:\r\n yield tup\r\n yield 0, \"</code>\"",
"def block_code(self, code, lang=None):\n code = code.rstrip('\\n')\n return [\"<code>\"] + code",
"... | [
"0.59630436",
"0.58044785",
"0.56429017",
"0.5612836",
"0.55475295",
"0.55050194",
"0.54975176",
"0.5452256",
"0.5361068",
"0.5346683",
"0.5345057",
"0.53445274",
"0.5304266",
"0.5297774",
"0.52917486",
"0.5278755",
"0.5259864",
"0.5249564",
"0.52428204",
"0.51822656",
"0.517... | 0.0 | -1 |
Performs the forward pass for the arms of the Siamese Neural Network. | def forward_once(self, inputs, inputs_lens = None):
# Determination of batch size
batch_size = inputs.size(0)
# Initialisation of hidden states
h0 = self.initialise_hidden(batch_size)
if self._embedding_dimensions is not None:
embedded_inputs = self.embeddin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, xs):\n\n xs = torch.split(xs, self.channel, -1)# list of batch, node, featdim\n xs = torch.stack(xs,2)#[batch, nodes, num_layers, num_channels]\n shape = xs.shape\n x = xs.reshape((-1,shape[2],shape[3])) # [ngraph * num_nodes , num_layers, num_channels]\n alpha... | [
"0.5942198",
"0.59067345",
"0.5743013",
"0.57251894",
"0.57186717",
"0.57123905",
"0.57045513",
"0.56750274",
"0.56567764",
"0.5613595",
"0.5606602",
"0.560122",
"0.55987453",
"0.5574207",
"0.55480045",
"0.55472565",
"0.5543803",
"0.5511937",
"0.5505923",
"0.55036813",
"0.550... | 0.0 | -1 |
Performs the computation of the last hidden states of the two inputs in parallel. | def forward(self, inputs1, inputs2, inputs1_lens = None, inputs2_lens = None, labels = None, predict = False):
if self._is_mlp:
output1 = self.mlp(inputs1.float())
output2 = self.mlp(inputs2.float())
else:
output1 = self.forward_once(inputs1, inputs1_lens)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call(self, inputs, states):\r\n (out_prev, Vm_prev) = states\r\n\r\n #Vm = Vm_prev * (1.0 - out_prev)\r\n #Lateral inhibition logic:\r\n Vm = Vm_prev * (1.0 - tf.reduce_max(out_prev))\r\n\r\n Vm = Vm * self.decay\r\n Vm = Vm + tf.matmul(inputs, self.kernel)\r\n ... | [
"0.6570047",
"0.61648476",
"0.6162371",
"0.6110056",
"0.60850364",
"0.6008825",
"0.60084426",
"0.5984341",
"0.59347737",
"0.5924735",
"0.5818022",
"0.58157426",
"0.5800721",
"0.5784431",
"0.57624656",
"0.57527184",
"0.5741885",
"0.5721153",
"0.56869733",
"0.5669856",
"0.56659... | 0.0 | -1 |
Energy function. Estimates the distance between the two outputs of the Siamese Neural Network according to a given distance metric. | def distance_layer(self, output1, output2, distance):
# Check definition in http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
# Redefined with L1 as per http://yann.lecun.com/exdb/publis/pdf/chopra-05.pdf
if self._loss == 'contrastive loss':
distance = 'l1'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def energy_func(self):\n return (\n self.inl[0].m.val_SI * (\n self.outl[0].h.val_SI - self.inl[0].h.val_SI) +\n self.inl[1].m.val_SI * (\n self.outl[1].h.val_SI - self.inl[1].h.val_SI))",
"def energy_func(self):\n i = self.inl[0].to_flow()\n ... | [
"0.6702598",
"0.6482071",
"0.63231647",
"0.6280572",
"0.6242269",
"0.6224302",
"0.6212535",
"0.618072",
"0.61790943",
"0.6144905",
"0.6110105",
"0.60883135",
"0.6077008",
"0.6064307",
"0.59443134",
"0.59062725",
"0.58995855",
"0.5882233",
"0.586689",
"0.58543587",
"0.58452326... | 0.58075607 | 24 |
Computes the specified loss function. | def get_loss(self, outputs, labels):
try:
assert self._loss in ['mse','mae','l1','l2','huber','logcosh','bce','contrastive'], 'Specify correct loss function'
except AssertionError as msg:
sys.exit(msg)
if self._loss == 'mse' or self._loss == 'l2':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loss_fn(self, targets, outputs, model):",
"def loss(self, x, y):\n\n return self.loss_fn(x, y)",
"def compute_loss(self, **kwargs):\n raise NotImplementedError",
"def compute_loss(self, *args, **kwargs):\n raise NotImplementedError",
"def compute_loss(self, features, mode, params, ... | [
"0.76312494",
"0.75961566",
"0.75804543",
"0.7543746",
"0.7502086",
"0.74650234",
"0.7456467",
"0.74020696",
"0.7317796",
"0.72831196",
"0.72803336",
"0.727307",
"0.7231247",
"0.7183014",
"0.71535593",
"0.713331",
"0.708863",
"0.70281285",
"0.7025106",
"0.70209706",
"0.701319... | 0.66546535 | 65 |
Initialisation of hidden states and cell states of LSTM to zero. Creation of two new tensors with sizes n_layers x batch_size x n_hidden. | def initialise_hidden(self, batch_size):
weight = next(self.parameters()).data
hidden = (weight.new(self._n_layers*self.directions, batch_size, self._hidden_size).zero_().to(self.device),
weight.new(self._n_layers*self.directions, batch_size, self._hidden_size).zero_().to(self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_hidden(self):\n # TODO ========================\n # initialize the hidden states to zero\n\n initial_hidden = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)\n return initial_hidden # a parameter tensor of shape (self.num_layers, self.batch_size, self.hidden_si... | [
"0.7726967",
"0.76643664",
"0.75588065",
"0.7465409",
"0.7465409",
"0.7406703",
"0.7388381",
"0.7388381",
"0.72557503",
"0.72025776",
"0.71975034",
"0.7117093",
"0.7048171",
"0.70436203",
"0.7036615",
"0.69667935",
"0.69302434",
"0.68985224",
"0.68985224",
"0.68985224",
"0.68... | 0.6283871 | 48 |
Initialisation of weights and biases for the embedding layer and the RNN layers. | def initialise_weights(self):
def initialise_process(param):
"""
Initialises weights of a given parameter following either Xavier or Kaiming uniform or normal processes.
: param (torch.Tensor):
"""
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_weight(self):\n init_layer(self.conv1)\n init_layer(self.conv2)\n init_bn(self.norm1)\n init_bn(self.norm2)",
"def instantiate_weights(self):\n with tf.variable_scope(\"embedding_projection\"), tf.device('/cpu:0'): # embedding matrix\n self.Embedding = tf.g... | [
"0.77943677",
"0.7777627",
"0.76114255",
"0.76029295",
"0.7508789",
"0.7387998",
"0.73835915",
"0.73677576",
"0.73591816",
"0.73591816",
"0.73591816",
"0.73556024",
"0.73530215",
"0.72580236",
"0.72257406",
"0.71798956",
"0.71372914",
"0.71090186",
"0.7084901",
"0.70644426",
... | 0.66120446 | 67 |
Initialises weights of a given parameter following either Xavier or Kaiming uniform or normal processes. | def initialise_process(param):
if self._initialisation_process == 'xavier_uniform':
tnni.xavier_uniform_(param.data)
elif self._initialisation_process == 'xavier_normal':
tnni.xavier_normal_(param.data)
elif self._initialisation_process ==... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_weight(self):\r\n xavier_init(self.output_proj, distribution='uniform', bias=0.)",
"def init_weights_(self):\n raise NotImplementedError",
"def initialise_weights(self): \n \n def initialise_process(param):\n \n \"\"\"\n Initialises weight... | [
"0.75284606",
"0.7397868",
"0.7371006",
"0.7275698",
"0.72356653",
"0.7192996",
"0.7187742",
"0.71090496",
"0.7088423",
"0.7076657",
"0.7066805",
"0.70589423",
"0.70522285",
"0.70522285",
"0.6999897",
"0.69886106",
"0.6960581",
"0.69561607",
"0.69436896",
"0.6931591",
"0.6925... | 0.65751314 | 54 |
Generates matrixes and layers to implement internal processing. | def build(self):
# Defining the layers
self.w1 = nn.Linear(self._hidden_size*2, self._expansion_size, bias = False).to(self.device)
self.tanh = nn.Tanh()
self.w2 = nn.Linear(self._expansion_size, self._attention_layers, bias = False).to(self.device)
self.softmax = nn.Sof... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assembleMatrices(self):\n # All nodes informations\n self.aircraftNodesPoints = []\n self.aircraftMassPoints = []\n self.aircraftMassDistances = []\n self.aircraftSegmentsLengths = []\n self.aircraftNodesNames = []\n self.aircraftInitNodesAreas = []\n sel... | [
"0.6531163",
"0.6477542",
"0.6408404",
"0.6279157",
"0.6247964",
"0.6191774",
"0.61850005",
"0.61850005",
"0.61787516",
"0.6170357",
"0.61396635",
"0.6123712",
"0.60545397",
"0.60288393",
"0.5991115",
"0.5973127",
"0.5918543",
"0.5913769",
"0.5901594",
"0.5899731",
"0.5898971... | 0.0 | -1 |
Forward pass of the bidirectional hidden states. | def forward(self, output):
hidden_states = self.extract_hidden_states(output)
# Obtaining the attention weights
weighted_states = self.w1(hidden_states)
activated_states = self.tanh(weighted_states)
score_weights = self.w2(activated_states)
attention_wei... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _bridge_bidirectional_hidden(self, hidden):\n num_layers = hidden.size(0) // 2\n _, batch_size, hidden_size = hidden.size()\n return hidden.view(num_layers, 2, batch_size, hidden_size)\\\n .transpose(1, 2).contiguous().view(num_layers, batch_size, hidden_size * 2)",
"def forwa... | [
"0.69670856",
"0.6397652",
"0.6265983",
"0.6238433",
"0.61677355",
"0.61020136",
"0.60459715",
"0.60427034",
"0.6039696",
"0.5999765",
"0.5988221",
"0.598384",
"0.5973033",
"0.5929639",
"0.591734",
"0.5909836",
"0.5899876",
"0.58930695",
"0.58797956",
"0.5878488",
"0.58754236... | 0.0 | -1 |
Extracts last hidden states from both directions. | def extract_hidden_states(self, output):
# Extracting the forward and backward hidden states from the last BiLSTM layer
# output (batch_size, sequence length, 2 * hidden dim)
output_fw = output[:,:,0:self._hidden_size]
output_bw = output[:,:,self._hidden_size:]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_hidden_states(self, output):\n # Intermediate hidden states\n output_fw_intermediate = output[:,:-1,0:self._hidden_size]\n output_bw_intermediate = output[:,1:,self._hidden_size:] \n \n # Last hidden states\n output_fw = output[:,-1,0:self._hidden_size]\n ... | [
"0.7700957",
"0.73588395",
"0.6921017",
"0.6706472",
"0.6245193",
"0.6230705",
"0.61972374",
"0.6155109",
"0.6091971",
"0.60544163",
"0.6048018",
"0.59658885",
"0.584702",
"0.58091694",
"0.58073974",
"0.57948864",
"0.5786997",
"0.5783306",
"0.5776817",
"0.57515407",
"0.575154... | 0.758297 | 1 |
Generates matrixes and layers to implement internal processing. | def build(self, weight = 0.5):
self.weight = weight
# Defining weighting matrixes
self.processing_fw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)
self.processing_bw = torch.randn((self._hidden_size, self._expansion_size)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assembleMatrices(self):\n # All nodes informations\n self.aircraftNodesPoints = []\n self.aircraftMassPoints = []\n self.aircraftMassDistances = []\n self.aircraftSegmentsLengths = []\n self.aircraftNodesNames = []\n self.aircraftInitNodesAreas = []\n sel... | [
"0.6533795",
"0.6478307",
"0.6406922",
"0.62815374",
"0.6245266",
"0.6195874",
"0.6190174",
"0.6190174",
"0.61767757",
"0.61684704",
"0.6142635",
"0.61235183",
"0.60565335",
"0.60293376",
"0.5989289",
"0.59723383",
"0.5916607",
"0.59163237",
"0.59031653",
"0.59013414",
"0.589... | 0.5499406 | 80 |
Forward pass of the bidirectional hidden states. | def forward(self, output):
last_ht, output_fw_intermediate, output_bw_intermediate = self.extract_hidden_states(output)
# Intermediate hidden state internal processing
output_reduced_fw = self.implement_processing(output_fw_intermediate, self.processing_fw)
output_reduc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _bridge_bidirectional_hidden(self, hidden):\n num_layers = hidden.size(0) // 2\n _, batch_size, hidden_size = hidden.size()\n return hidden.view(num_layers, 2, batch_size, hidden_size)\\\n .transpose(1, 2).contiguous().view(num_layers, batch_size, hidden_size * 2)",
"def forwa... | [
"0.69670856",
"0.6397652",
"0.6265983",
"0.6238433",
"0.61677355",
"0.61020136",
"0.60459715",
"0.60427034",
"0.6039696",
"0.5999765",
"0.5988221",
"0.598384",
"0.5973033",
"0.5929639",
"0.591734",
"0.5909836",
"0.5899876",
"0.58930695",
"0.58797956",
"0.5878488",
"0.58754236... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.